home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Internet / WWW / analog / Source / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-07  |  87.3 KB  |  2,848 lines
  1. /*** analog 1.9beta ***/
  2. /* Please read Readme.html, or http://www.statslab.cam.ac.uk/~sret1/analog/  */
  3.  
  4. /*** init.c; initialisation routines and declaration of global variables ***/
  5.  
  6. #include "analhea2.h"
  7.  
  8. /*** First declare all global variables. We choose to declare them in this
  9.      file rather than analog.c because more are needed here. ***/
  10.  
  11. char dayname[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  12. char monthname[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
  13.                "Aug", "Sep", "Oct", "Nov", "Dec"};
  14. /* Note: month numbers run from 0 (Jan) to 11 (Dec) internally to this
  15.    program (though not where month numbers are needed in user input and
  16.    output) */
  17. int dateoffset[12] = {0, 31, 59, 90, 120, 151, 181,
  18.             212, 243, 273, 304, 334};
  19. int monthlength[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  20.  
  21. char errs[NO_ERRS][MAXERRLENGTH] = {"Send timed out", "File does not exist",
  22. "No file matching URL", "User does not exist", "Send aborted",
  23. "Timed out waiting", "File permissions deny server access",
  24. "Client denied by server configuration", "Malformed header from script",
  25. "Killing CGI process", "Could not get local address", "Will not follow link",
  26. "Could not get port number", "Script does not exist", "Script not found",
  27. "Unable to include", "Could not fork new process",
  28. "Unable to fork new process", "Invalid CGI ref",
  29. "Caught SIGTERM, shutting down", "Caught SIGSEGV, dumping core",
  30. "Caught SIGHUP, restarting", "SIGHUP received.  Attempting to restart",
  31. "Successful restart", "Resuming normal operations", "Starting",
  32. "Child error: pass failed", "Socket error: accept failed", ""};
  33.       /* last must be "" */    
  34. int errors[NO_ERRS];   /* how many occurrences of each */
  35. int statusnos[NO_STATUS] = {200, 201, 202, 203, 204, 299, 301, 302, 303, 304,
  36. 399, 400, 401, 402, 403, 404, 499, 500, 501, 502, 503, 599};
  37. /* all status codes */
  38. char statusstrs[NO_STATUS][MAXSTATUSLENGTH] = {"OK", "Created",
  39. "Accepted for future processing", "Partial information",
  40. "OK, but nothing to send", "[Miscellaneous successes]", "Document moved",
  41. "Document found elsewhere", "Moved; use another request method",
  42. "Not modified since last retrieval", "[Miscellaneous redirections]",
  43. "Bad request", "Authorisation required", "Payment required", "Forbidden",
  44. "Document not found", "[Miscellaneous client/user errors]",
  45. "Internal server error", "Request type not supported",
  46. "Server overloaded", "Gateway timed out", "[Miscellaneous server errors]"};
  47. int status[NO_STATUS];   /* how many of each have been seen */
  48. int status7[NO_STATUS];  /* ditto in last 7 days */
  49.  
  50. char outfile[MAXSTRINGLENGTH];
  51.  
  52. struct timestruct firsttime, lasttime, starttimec, oldtime, fromtime, totime;
  53. /* first and last log entries, now, a week before now, and
  54.    lower and upper bounds on time interval we want to consider */
  55.  
  56. struct monthly *firstm, *lastm;
  57.     /* pointers to the first and last years of monthly data */
  58. struct daily *firstd, *lastd;   /* ... months of daily data */
  59. struct hourly *firsth, *lasth;  /* ... days of hourly data */
  60. struct weekly *firstw, *lastw;  /* ... and to the first and last week */
  61.  
  62. int no_urls;                  /* the number of distinct files found so far */
  63. int no_urls7;                 /* the number used in the last 7 days */
  64. struct genstruct *urlhead[URLHASHSIZE];  /* hash table of all files found */
  65. struct genstruct *dirhead[DIRHASHSIZE];  /* and one for all directories */
  66. struct domain *subdomhead[SUBDOMHASHSIZE];  /* one for subdomains */
  67. struct domain *wildsubdomhead;     /* and one for wild subdomains */
  68. struct domain *nwildsubdomhead;    /* and one for wild numerical subdomains */
  69. int no_hosts;                 /* the number of hosts so far */
  70. int no_hosts7;                /* the number of all hosts in the last 7 days */
  71. int no_new_hosts7;            /* the number of new hosts in the last 7 days */
  72. struct genstruct *hosthead[HOSTHASHSIZE];  /* and a record of all hosts */
  73. char *approxhostspace;       /* start of the space for approx host counting */
  74. char *approxhostspace7;      /* and a bit more for last 7 days accounting */
  75. int approxhostsize;          /* the size of those spaces, in bytes */
  76. struct domain *domainhead[DOMHASHSIZE];
  77. struct genstruct *refhead[REFHASHSIZE];
  78. struct genstruct *browhead[BROWHASHSIZE];
  79. struct genstruct *fullbrowhead[FULLBROWHASHSIZE];
  80.  
  81. struct alias *filealiashead, *hostaliashead, *refaliashead, *subdomshead;
  82.     /* subdomshead is not really an alias, but it's the right shape */
  83. struct include *wantfilehead, *wanthosthead, *wantrefhead;
  84. struct include *ispagehead, *noexpandhead, *refexpandhead;
  85.  
  86. int dailyreq[7];            /* requests for each day */
  87. int hourlyreq[24];          /* ... and hour */
  88. double dailybytes[7];       /* ... and bytes ditto */
  89. double hourlybytes[24];
  90.  
  91. int url_max_reqs;        /* the max reqs for any file */
  92. int dir_max_reqs;        /* for any directory */
  93. int host_max_reqs;       /* for any host */
  94. int dom_max_reqs;        /* for any domain */
  95. int ref_max_reqs;        /* for any referer */
  96. int brow_max_reqs;       /* for any browser */
  97. int fullbrow_max_reqs;   /* for any browser (full name) */
  98.  
  99. double url_max_bytes;    /* the same for max bytes */
  100. double dir_max_bytes;
  101. double host_max_bytes;
  102. double dom_max_bytes;
  103. double ref_max_bytes;
  104. double brow_max_bytes;
  105. double fullbrow_max_bytes;
  106.  
  107. int host_max_length;     /* and the same for length of name */
  108.  
  109. int dirsufflength;  /* the length of DIRSUFFIX */
  110. int onumber, subonumber;  /* the number of (sub)domains in the domain report */
  111. time_t starttime, stoptime;
  112. char starttimestr[26];     /* the start and stop time of the program */
  113. double total_bytes;
  114. double total_bytes7;
  115. int corrupt_lines;         /* the number of corrupt lines in the logfile */
  116.                              /* (Overlong lines, URLs with quotes in...) */
  117. int other_lines;           /* Lines masked out */
  118. int cachereqs, cachereqs7; /* The number of requests from cache */
  119. flag byq, refbyq, browbyq; /* whether we want to count bytes; always on until
  120.                   we find a line with no bytes information. */
  121. flag rawbytes;   /* whether bytes are quoted raw or in k notation */
  122. flag graphical;  /* whether to draw pretty graphs or just use ASCII art */
  123. flag filemaskq, hostmaskq, refmaskq;
  124. /* whether there is any masking of hosts, files or refs */
  125.  
  126. int weekbeginson;  /* which is the first day of the week? */
  127. char sepchar;      /* character as separator in, e.g., 23 000 000 */
  128.  
  129. char commandname[MAXSTRINGLENGTH];  /* the name of the program, as called */
  130.  
  131. char baseurl[MAXSTRINGLENGTH];     /* base URL for all URLs found */
  132. char reqcols[5], dircols[5], hostcols[5], domcols[5], refcols[5], browcols[5];
  133. char fullbrowcols[5], monthcols[5], daycols[5], fulldaycols[5], weekcols[5];
  134. char hourcols[5], fullhourcols[5];      /* Columns appearing in each report */
  135.  
  136. struct loglist *logfilehead, *uncompresshead;
  137. /* uncompress is not really a loglist, but it's the right shape */
  138. struct stringlist *cachefilehead, *refloghead, *browloghead, *errloghead;
  139. char domainsfile[MAXSTRINGLENGTH];
  140. char logourl[MAXSTRINGLENGTH];
  141. char imagedir[MAXSTRINGLENGTH];
  142. char headerfile[MAXSTRINGLENGTH], footerfile[MAXSTRINGLENGTH];
  143. char reportorder[18];  /* the order in which reports occur (room for more) */
  144. flag xq, mq, oq, iq, rq, q7, dq, hq, Hq, Sq, Dq, Wq, fq, bq, Bq, cq, eq;
  145. int sq, aq;  /* a: output type     x->s: whether we want each type of report */
  146. flag warnq;             /* whether we want warnings */
  147. int monthlyunit, weeklyunit, dailyunit, fulldailyunit, hourlyunit;
  148. int fullhourlyunit;  /* the size of the mark in the graphical displays */
  149. char domminreqstr[MAXSTRINGLENGTH], subdomminreqstr[MAXSTRINGLENGTH];
  150. char hostminreqstr[MAXSTRINGLENGTH], dirminreqstr[MAXSTRINGLENGTH];
  151. char urlminreqstr[MAXSTRINGLENGTH], refminreqstr[MAXSTRINGLENGTH];
  152. char browminreqstr[MAXSTRINGLENGTH], fullbrowminreqstr[MAXSTRINGLENGTH];
  153. char domminbytestr[MAXSTRINGLENGTH], subdomminbytestr[MAXSTRINGLENGTH];
  154. char hostminbytestr[MAXSTRINGLENGTH], dirminbytestr[MAXSTRINGLENGTH];
  155. char urlminbytestr[MAXSTRINGLENGTH], refminbytestr[MAXSTRINGLENGTH];
  156. char browminbytestr[MAXSTRINGLENGTH], fullbrowminbytestr[MAXSTRINGLENGTH];
  157. int errminreqs;
  158. char monthgraph, daygraph, fulldaygraph, hourgraph, fullhourgraph, weekgraph;
  159. flag mback, Dback, Wback, Hback;
  160. int domsortby, dirsortby, hostsortby, reqsortby, refsortby, browsortby;
  161. int fullbrowsortby;
  162. int dirlevel, reqtype, pagewidth;
  163. char markchar;
  164. char hostname[MAXSTRINGLENGTH], hosturl[MAXSTRINGLENGTH];
  165. int kq;        /* default PAGELINKS */
  166. int debug;
  167.  
  168. flag vblesonly;  /* commandline only. If ON, just print variables and exit */
  169. flag formq;      /* commandline only. If ON, just make a form interface */
  170.  
  171. extern void *xmalloc();   /* in utils.c */
  172. extern void *xcalloc();   /* in utils.c */
  173.  
  174. /* We also declare the following pointers as global here. They are not used
  175.    outside this file, but we want to keep track of all of them between
  176.    various functions within this file. */
  177.  
  178. struct alias *filealiasp, *hostaliasp, *refaliasp, *subdomp, *subdomtempp;
  179. struct include *wantfilep, *wanthostp, *wantrefp, *ispagep, *noexpandp;
  180. struct include *refexpandp;
  181. struct loglist *logfilep, *uncompressp;
  182. struct stringlist *cachefilep, *reflogp, *browlogp, *errlogp;
  183.  
  184. /*** Next, the function that parses the domains file ***/
  185.  
  186. void domainscan(void)
  187. {
  188.   extern flag subdomadd();        /* in hash.c */
  189.   extern int sscanf_domains();    /* in sscanf.c */
  190.  
  191.   FILE *df;
  192.   struct domain *domp, *domlastp;
  193.   /* Recycle global struct alias *subdomp; */
  194.   char tempstr[MAXSTRINGLENGTH], tempstr2[MAXSTRINGLENGTH];
  195.   char inputline[MAXLINELENGTH];
  196.   int rc;    /* return code */
  197.   int domcode;   /* the code of a particular domain;
  198.             see the long comment just below */
  199.  
  200.   df = fopen(domainsfile, "r");
  201.   if (df == NULL) {
  202.     if (warnq) {
  203.       fprintf(stderr, "%s: Warning: Failed to open domains file \"%s\":\n",
  204.           commandname, domainsfile);
  205.       fprintf(stderr,"  will not construct domain report.\n");
  206.     }
  207.     oq = OFF;
  208.     return;
  209.   }
  210.  
  211.   /* We put the domains in the following order. aa = 0, ab = 2, ...,
  212.      ba = 52, ... Domains with more than two letters go in the spaces;
  213.      co = 134, com = 135, cp = 136. We assume that there are no two long
  214.      domain names with the same two initial letters. Finally zz = 1350,
  215.      zzspam = 1351, Unknown = 1352, Numerical = 1353. Each domain contains
  216.      a 'nexti' element to show which is the next domain that occurs in the
  217.      domains file. */
  218.  
  219.   else {   /* there is a domains file */
  220.     domp = domainhead[DOMHASHSIZE - 2];
  221.     domp -> id = xmalloc(5);      /* enough for "*UNK\0" */
  222.     strcpy(domp -> id, "*UNK");
  223.     domp -> name = xmalloc(8);
  224.     strcpy(domp -> name, "unknown");
  225.     domp -> reqs = 0;
  226.     domp -> bytes = 0;
  227.     domp -> next = (struct domain *)xmalloc(sizeof(struct domain));
  228.     domp -> next -> name = NULL;
  229.     domp = domainhead[DOMHASHSIZE - 1];
  230.     domp -> id = xmalloc(5);
  231.     strcpy(domp -> id, "*NUM");
  232.     domp -> name = xmalloc(31);
  233.     strcpy(domp -> name, "unresolved numerical addresses");
  234.     domp -> reqs = 0;
  235.     domp -> bytes = 0;
  236.     domp -> next = (struct domain *)xmalloc(sizeof(struct domain));
  237.     domp -> next -> name = NULL;
  238.     domlastp = domp;
  239.     domp = domp -> next;
  240.  
  241.     while (fgets(inputline, MAXLINELENGTH, df) != NULL) {
  242.       rc = sscanf_domains(inputline, tempstr, tempstr2);
  243.       if (rc == 2) {
  244.     if ((!isdigit(tempstr[0])) && strchr(tempstr, '.') == NULL) {
  245.                                                     /* new domain */
  246.       domcode = (tempstr[0] - 'a') * 52 + (tempstr[1] - 'a') * 2 +
  247.         (tempstr[2] != '\0');
  248.       if ((domcode < 0 || domcode > DOMHASHSIZE - 3) && warnq) {
  249.         fprintf(stderr, "%s: Warning: Ignoring corrupt line in domains file looking like\n", commandname);
  250.         fprintf(stderr,"  %s", inputline);
  251.       }
  252.       domp = domainhead[domcode];
  253.       domp -> id = xmalloc((size_t)((int)strlen(tempstr) + 1));
  254.       strcpy(domp -> id, tempstr);
  255.       domp -> name = xmalloc((size_t)((int)strlen(tempstr2) + 1));
  256.       strcpy(domp -> name, tempstr2);
  257.       domp -> reqs = 0;
  258.       domp -> bytes = 0;
  259.       domp -> next = (struct domain *)xmalloc(sizeof(struct domain));
  260.       domp -> next -> name = NULL;
  261.       domlastp -> nexti = domcode;
  262.                             /* domlastp is the last domain we looked at */
  263.       domlastp = domp;
  264.       domp = domp -> next;
  265.     }
  266.     else if (warnq) {   /* old specification subdomain */
  267.       fprintf(stderr,
  268.           "%s: Warning: Subdomains should now be specified in configuration\n",
  269.           commandname);
  270.       fprintf(stderr, "  file, not domains file. Ignoring line\n  %s",
  271.           inputline);
  272.     }
  273.       }
  274.       else if (rc == 1 && warnq) {
  275.     fprintf(stderr, "%s: Warning: Ignoring corrupt line in domains file looking like\n", commandname);
  276.     fprintf(stderr, "  %s", inputline);
  277.       }
  278.     }
  279.  
  280.     domlastp -> nexti = -1;   /* marker; last domain has no subsequent one */
  281.     
  282.     fclose(df);
  283.  
  284.     /* Now do the subdomains which we read in at configuration time */
  285.  
  286.     for (subdomp = subdomshead; subdomp -> from[0] != '\0';
  287.      subdomp = subdomp -> next)
  288.       if (subdomp -> from[0] != '?')
  289.     subdomadd(subdomp -> from, subdomp -> to);
  290.  
  291.   }     /* end else can read domains file */
  292. }
  293.  
  294.  
  295. /*** Now boring functions for initialisation of variables etc. ***/
  296.  
  297. void defaults(void)
  298. {
  299.   strncpy(domainsfile, DOMAINSFILE, MAXSTRINGLENGTH - 1);
  300.   domainsfile[MAXSTRINGLENGTH - 1] = '\0';
  301.   strncpy(headerfile, HEADERFILE, MAXSTRINGLENGTH - 1);
  302.   headerfile[MAXSTRINGLENGTH - 1] = '\0';
  303.   strncpy(footerfile, FOOTERFILE, MAXSTRINGLENGTH - 1);
  304.   footerfile[MAXSTRINGLENGTH - 1] = '\0';
  305.   strncpy(outfile, OUTFILE, MAXSTRINGLENGTH - 1);
  306.   outfile[MAXSTRINGLENGTH - 1] = '\0';
  307.   strncpy(baseurl, BASEURL, MAXSTRINGLENGTH - 1);
  308.   baseurl[MAXSTRINGLENGTH - 1] = '\0';
  309.   strncpy(imagedir, IMAGEDIR, MAXSTRINGLENGTH - 1);
  310.   imagedir[MAXSTRINGLENGTH - 1] = '\0';
  311.   strncpy(reportorder, REPORTORDER, 15);
  312.   reportorder[15] = '\0';
  313.   strncpy(domcols, DOMCOLS, 4);
  314.   domcols[4] = '\0';
  315.   strncpy(hostcols, HOSTCOLS, 4);
  316.   hostcols[4] = '\0';
  317.   strncpy(dircols, DIRCOLS, 4);
  318.   dircols[4] = '\0';
  319.   strncpy(reqcols, REQCOLS, 4);
  320.   reqcols[4] = '\0';
  321.   strncpy(refcols, REFCOLS, 4);
  322.   refcols[4] = '\0';
  323.   strncpy(browcols, BROWCOLS, 4);
  324.   browcols[4] = '\0';
  325.   strncpy(fullbrowcols, FULLBROWCOLS, 4);
  326.   fullbrowcols[4] = '\0';
  327.   strncpy(monthcols, MONTHCOLS, 4);
  328.   monthcols[4] = '\0';
  329.   strncpy(daycols, DAYCOLS, 4);
  330.   daycols[4] = '\0';
  331.   strncpy(fulldaycols, FULLDAYCOLS, 4);
  332.   fulldaycols[4] = '\0';
  333.   strncpy(weekcols, WEEKCOLS, 4);
  334.   weekcols[4] = '\0';
  335.   strncpy(hourcols, HOURCOLS, 4);
  336.   hourcols[4] = '\0';
  337.   strncpy(fullhourcols, FULLHOURCOLS, 4);
  338.   fullhourcols[4] = '\0';
  339.   strcpy(logourl, LOGOURL);
  340.   mq = MONTHLY;
  341.   Wq = WEEKLY;
  342.   dq = DAILY;
  343.   Dq = FULLDAILY;
  344.   hq = HOURLY;
  345.   Hq = FULLHOURLY;
  346.   oq = DOMAINREP;
  347.   iq = DIRECTORY;
  348.   rq = REQUEST;
  349.   sq = COUNTHOSTS;
  350.   Sq = FULLHOSTS;
  351.   fq = REFERER;
  352.   bq = BROWSER;
  353.   Bq = FULLBROWSER;
  354.   cq = STATUS;
  355.   eq = ERROR;
  356.   xq = GENERAL;
  357.   q7 = LASTSEVEN;
  358.   aq = OUTPUT;
  359.   warnq = WARNINGS;
  360.   graphical = GRAPHICAL;
  361.   monthlyunit = 0;
  362.   weeklyunit = 0;
  363.   hourlyunit = 0;
  364.   fullhourlyunit = 0;
  365.   dailyunit = 0;
  366.   fulldailyunit = 0;
  367.   monthgraph = MONTHGRAPH;
  368.   daygraph = DAYGRAPH;
  369.   fulldaygraph = FULLDAYGRAPH;
  370.   hourgraph = HOURGRAPH;
  371.   fullhourgraph = FULLHOURGRAPH;
  372.   weekgraph = WEEKGRAPH;
  373.   Hback = FULLHOURLYBACK;
  374.   Dback = FULLDAILYBACK;
  375.   Wback = WEEKLYBACK;
  376.   mback = MONTHLYBACK;
  377.   domsortby = DOMSORTBY;
  378.   dirsortby = DIRSORTBY;
  379.   reqsortby = REQSORTBY;
  380.   hostsortby = HOSTSORTBY;
  381.   refsortby = REFSORTBY;
  382.   browsortby = BROWSORTBY;
  383.   fullbrowsortby = FULLBROWSORTBY;
  384.   strncpy(domminreqstr, MIN_DOM_REQS, MAXSTRINGLENGTH - 1);
  385.   domminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  386.   strncpy(domminbytestr, MIN_DOM_BYTES, MAXSTRINGLENGTH - 1);
  387.   domminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  388.   strncpy(subdomminreqstr, MIN_SUBDOM_REQS, MAXSTRINGLENGTH - 1);
  389.   subdomminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  390.   strncpy(subdomminbytestr, MIN_SUBDOM_BYTES, MAXSTRINGLENGTH - 1);
  391.   subdomminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  392.   strncpy(dirminreqstr, MIN_DIR_REQS, MAXSTRINGLENGTH - 1);
  393.   dirminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  394.   strncpy(dirminbytestr, MIN_DIR_BYTES, MAXSTRINGLENGTH - 1);
  395.   dirminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  396.   strncpy(hostminreqstr, MIN_HOST_REQS, MAXSTRINGLENGTH - 1);
  397.   hostminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  398.   strncpy(hostminbytestr, MIN_HOST_BYTES, MAXSTRINGLENGTH - 1);
  399.   hostminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  400.   strncpy(urlminreqstr, MIN_URL_REQS, MAXSTRINGLENGTH - 1);
  401.   urlminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  402.   strncpy(urlminbytestr, MIN_URL_BYTES, MAXSTRINGLENGTH - 1);
  403.   urlminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  404.   strncpy(refminreqstr, MIN_REF_REQS, MAXSTRINGLENGTH - 1);
  405.   refminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  406.   strncpy(refminbytestr, MIN_REF_BYTES, MAXSTRINGLENGTH - 1);
  407.   refminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  408.   strncpy(browminreqstr, MIN_BROW_REQS, MAXSTRINGLENGTH - 1);
  409.   browminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  410.   strncpy(browminbytestr, MIN_BROW_BYTES, MAXSTRINGLENGTH - 1);
  411.   browminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  412.   strncpy(fullbrowminreqstr, MIN_FULLBROW_REQS, MAXSTRINGLENGTH - 1);
  413.   fullbrowminreqstr[MAXSTRINGLENGTH - 1] = '\0';
  414.   strncpy(fullbrowminbytestr, MIN_FULLBROW_BYTES, MAXSTRINGLENGTH - 1);
  415.   fullbrowminbytestr[MAXSTRINGLENGTH - 1] = '\0';
  416.   errminreqs = MIN_ERR_OCCS;
  417.   dirlevel = DIRLEVEL;
  418.   reqtype = REQTYPE;
  419.   pagewidth = PAGEWIDTH;
  420.   markchar = MARKCHAR;
  421.   rawbytes = RAWBYTES;
  422.   strncpy(hostname, HOSTNAME, MAXSTRINGLENGTH - 1);
  423.   hostname[MAXSTRINGLENGTH - 1] = '\0';
  424.   strncpy(hosturl, HOSTURL, MAXSTRINGLENGTH - 1);
  425.   hosturl[MAXSTRINGLENGTH - 1] = '\0';
  426.   kq = PAGELINKS;
  427.   weekbeginson = WEEKBEGINSON;
  428.   sepchar = SEPCHAR;
  429.   vblesonly = OFF;
  430.   formq = OFF;
  431.   fromtime.code = -INFINITY;
  432.   totime.code = INFINITY;
  433.   approxhostsize = APPROXHOSTSIZE;
  434.   debug = DEBUG;
  435.   filemaskq = OFF;
  436.   hostmaskq = OFF;
  437.   refmaskq = OFF;
  438. }
  439.  
  440. void init_structs(void)
  441. {
  442.   extern void addlogfile(), configstrlist();     /* later in this file */
  443.   char tempstr[MAXSTRINGLENGTH];
  444.  
  445.   logfilehead = (struct loglist *)xmalloc(sizeof(struct loglist));
  446.   logfilep = logfilehead;
  447.   if (STREQ(LOGFILE, "none"))
  448.     logfilehead -> name[0] = '\0';
  449.   else {
  450.     strcpy(tempstr, LOGFILE);
  451.     addlogfile(&logfilep, tempstr, "");
  452.   }
  453.   cachefilehead = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  454.   cachefilep = cachefilehead;
  455.   if (STREQ(CACHEFILE, "none"))
  456.     cachefilehead -> name[0] = '\0';
  457.   else {
  458.     strcpy(tempstr, CACHEFILE);
  459.     configstrlist(tempstr, &cachefilep, (char *)NULL, (char *)NULL, 2);
  460.   }
  461.   refloghead = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  462.   reflogp = refloghead;
  463.   if (STREQ(REFERER_LOG, "none"))
  464.     refloghead -> name[0] = '\0';
  465.   else{
  466.     strcpy(tempstr, REFERER_LOG);
  467.     configstrlist(tempstr, &reflogp, (char *)NULL, (char *)NULL, 2);
  468.   }
  469.   browloghead = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  470.   browlogp = browloghead;
  471.   if (STREQ(BROWSER_LOG, "none"))
  472.     browloghead -> name[0] = '\0';
  473.   else {
  474.     strcpy(tempstr, BROWSER_LOG);
  475.     configstrlist(tempstr, &browlogp, (char *)NULL, (char *)NULL, 2);
  476.   }
  477.   errloghead = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  478.   errlogp = errloghead;
  479.   if (STREQ(ERROR_LOG, "none"))
  480.     errloghead -> name[0] = '\0';
  481.   else {
  482.     strcpy(tempstr, ERROR_LOG);
  483.     configstrlist(tempstr, &errlogp, (char *)NULL, (char *)NULL, 2);
  484.   }
  485.   uncompresshead = (struct loglist *)xmalloc(sizeof(struct loglist));
  486.   uncompresshead -> name[0] = '\0';
  487.   uncompressp = uncompresshead;
  488.   filealiashead = (struct alias *)xmalloc(sizeof(struct alias));
  489.   filealiashead -> from[0] = '\0';
  490.   filealiasp = filealiashead;
  491.   hostaliashead = (struct alias *)xmalloc(sizeof(struct alias));
  492.   hostaliashead -> from[0] = '\0';
  493.   hostaliasp = hostaliashead;
  494.   refaliashead = (struct alias *)xmalloc(sizeof(struct alias));
  495.   refaliashead -> from[0] = '\0';
  496.   refaliasp = refaliashead;
  497.   wantfilehead = (struct include *)xmalloc(sizeof(struct include));
  498.   wantfilehead -> in = UNSET;
  499.   wantfilep = wantfilehead;
  500.   wanthosthead = (struct include *)xmalloc(sizeof(struct include));
  501.   wanthosthead -> in = UNSET;
  502.   wanthostp = wanthosthead;
  503.   subdomshead = (struct alias *)xmalloc(sizeof(struct alias));
  504.   subdomshead -> from[0] = '\0';
  505.   subdomp = subdomshead;
  506.   wantrefhead = (struct include *)xmalloc(sizeof(struct include));
  507.   wantrefhead -> in = UNSET;
  508.   wantrefp = wantrefhead;
  509.   noexpandhead = (struct include *)xmalloc(sizeof(struct include));
  510.   noexpandhead -> in = UNSET;
  511.   noexpandp = noexpandhead;
  512.   refexpandhead = (struct include *)xmalloc(sizeof(struct include));
  513.   refexpandhead -> in = UNSET;
  514.   refexpandp = refexpandhead;
  515.   ispagehead = (struct include *)xmalloc(sizeof(struct include));
  516.   ispagep = ispagehead;
  517.   strcpy(ispagep -> name, "*.html");
  518.   ispagep -> in = TRUE;
  519.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  520.   ispagep = ispagep -> next;
  521.   strcpy(ispagep -> name, "*/");
  522.   ispagep -> in = TRUE;
  523.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  524.   ispagep = ispagep -> next;
  525.   strcpy(ispagep -> name, "*.htm");
  526.   ispagep -> in = TRUE;
  527.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  528.   ispagep = ispagep -> next;
  529.   strcpy(ispagep -> name, "*.shtml");
  530.   ispagep -> in = TRUE;
  531.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  532.   ispagep = ispagep -> next;
  533.   strcpy(ispagep -> name, "*.shtm");
  534.   ispagep -> in = TRUE;
  535.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  536.   ispagep = ispagep -> next;
  537.   strcpy(ispagep -> name, "*.html3");
  538.   ispagep -> in = TRUE;
  539.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  540.   ispagep = ispagep -> next;
  541.   strcpy(ispagep -> name, "*.ht3");
  542.   ispagep -> in = TRUE;
  543.   ispagep -> next = (struct include *)xmalloc(sizeof(struct include));
  544.   ispagep -> next -> in = UNSET;
  545. }
  546.  
  547. void othervars(void)    /* vars initialised after command args and config */
  548. {
  549.   extern long timecode();     /* in utils.c */
  550.  
  551.   char oldmonth[4];           /* the time 7 days ago */
  552.   long oldtimeno;
  553.   char oldtimestr[26];
  554.   int i;
  555.  
  556.   no_urls = 0;
  557.   no_urls7 = 0;
  558.   no_hosts = 0;
  559.   no_hosts7 = 0;
  560.   no_new_hosts7 = 0;
  561.   url_max_reqs = 0;
  562.   dir_max_reqs = 0;
  563.   host_max_reqs = 0;
  564.   url_max_bytes = 0;
  565.   dir_max_bytes = 0;
  566.   host_max_bytes = 0;         /* dom_max_reqs and _bytes are set later */
  567.   host_max_length = 0;
  568.   for (i = 0; i < NO_STATUS; i++) {
  569.     status[i] = 0;
  570.     status7[i] = 0;
  571.   }
  572.   total_bytes = 0.0;
  573.   total_bytes7 = 0.0;
  574.   corrupt_lines = 0;
  575.   other_lines = 0;
  576.   cachereqs = 0;
  577.   cachereqs7 = 0;
  578.   byq = ON;
  579.   refbyq = ON;
  580.   browbyq = ON;
  581.  
  582.   /* initialise the date structures */
  583.   if (mq) {
  584.     firstm = (struct monthly *)xmalloc(sizeof(struct monthly));
  585.     for (i = 0; i < 12; i++) {
  586.       firstm -> reqs[i] = 0;
  587.       firstm -> bytes[i] = 0.0;
  588.     }
  589.     firstm -> next = NULL;
  590.     lastm = firstm;
  591.   }
  592.   if (Dq) {
  593.     firstd = (struct daily *)xmalloc(sizeof(struct daily));
  594.     for (i = 0; i < 31; i++) {
  595.       firstd -> reqs[i] = 0;
  596.       firstd -> bytes[i] = 0.0;
  597.     }
  598.     firstd -> next = NULL;
  599.     lastd = firstd;
  600.   }
  601.   if (Hq) {
  602.     firsth = (struct hourly *)xmalloc(sizeof(struct hourly));
  603.     for (i = 0; i < 24; i++) {
  604.       firsth -> reqs[i] = 0;
  605.       firsth -> bytes[i] = 0.0;
  606.     }
  607.     firsth -> next = NULL;
  608.     lasth = firsth;
  609.   }
  610.   if (Wq) {
  611.     firstw = (struct weekly *)xmalloc(sizeof(struct weekly));
  612.     firstw -> reqs = 0;
  613.     firstw -> bytes = 0;
  614.     firstw -> next = NULL;
  615.     lastw = firstw;
  616.   }
  617.   if (dq) {
  618.     for (i = 0; i < 7; i++) {
  619.       dailyreq[i] = 0;
  620.       dailybytes[i] = 0.0;
  621.     }
  622.   }
  623.   if (hq) {
  624.     for (i = 0; i < 24; i++) {
  625.       hourlyreq[i] = 0;
  626.       hourlybytes[i] = 0.0;
  627.     }
  628.   }
  629.  
  630.   if (q7) {   /* calculate the time 7 days ago */
  631.     if (starttimec.code <= totime.code) {
  632.       oldtimeno = starttime - 604800;        /* seconds in a week */
  633.       strcpy(oldtimestr, (char *)(ctime((time_t *)(&oldtimeno))));
  634.       oldtime.year = (oldtimestr[23] - '0') + (oldtimestr[22] - '0') * 10
  635.     + (oldtimestr[21] - '0') * 100 + (oldtimestr[20] - '0') * 1000;
  636.       oldtime.min = (oldtimestr[15] - '0') + (oldtimestr[14] - '0') * 10;
  637.       oldtime.hr = (oldtimestr[12] - '0') + (oldtimestr[11] - '0') * 10;
  638.       oldtime.date = (oldtimestr[9] - '0');
  639.       if (oldtimestr[8] != ' ')
  640.     oldtime.date += (oldtimestr[8] - '0') * 10;
  641.       oldtimestr[7] = '\0';
  642.       strcpy(oldmonth, oldtimestr + 4);
  643.       oldtime.monthno = strtomonth(oldmonth);
  644.     }
  645.     else {    /* totime is earlier than today; take 7 days before that */
  646.       oldtime.hr = 23;
  647.       oldtime.min = 59;
  648.       oldtime.year = totime.year;
  649.       oldtime.monthno = totime.monthno;
  650.       oldtime.date = totime.date - 7;
  651.       if (oldtime.date < 1) {
  652.     oldtime.monthno--;
  653.     if (oldtime.monthno < 0) {
  654.       oldtime.year--;
  655.       oldtime.monthno += 12;
  656.     }
  657.     oldtime.date += monthlength[oldtime.monthno] +
  658.       ISLEAPFEB(oldtime.monthno, oldtime.year);
  659.       }
  660.     }
  661.     oldtime.code = timecode(oldtime.date, oldtime.monthno, oldtime.year,
  662.                 oldtime.hr, oldtime.min);
  663.     if (oldtime.code < fromtime.code)
  664.       q7 = OFF;  /* FROM--TO is all in last 7 days */
  665.   }
  666.   
  667.   dirsufflength = (int)strlen(DIRSUFFIX);
  668.     
  669.   if (rq || iq) {   /* we do a (silent) req. report if iq as well */
  670.     for (i = 0; i < URLHASHSIZE; i++) {
  671.       urlhead[i] = (struct genstruct *)xmalloc(sizeof(struct genstruct));
  672.       urlhead[i] -> name = NULL;
  673.     }
  674.   }
  675.   if (iq) {
  676.     for (i = 0; i < DIRHASHSIZE; i++) {
  677.       dirhead[i] = (struct genstruct *)xmalloc(sizeof(struct genstruct));
  678.       dirhead[i] -> name = NULL;
  679.     }
  680.   }
  681.   if (sq == ON) {
  682.     for (i = 0; i < HOSTHASHSIZE; i++) {
  683.       hosthead[i] = (struct genstruct *)xmalloc(sizeof(struct genstruct));
  684.       hosthead[i] -> name = NULL;
  685.     }
  686.   }
  687.   else if (sq == APPROX) {
  688.     approxhostspace = (char *) xcalloc(approxhostsize, 1);
  689.     if (q7)
  690.       approxhostspace7 = (char *) xcalloc(approxhostsize, 1);
  691.   }
  692.   if (fq) {
  693.     for (i = 0; i < REFHASHSIZE; i++) {
  694.       refhead[i] = (struct genstruct *)xmalloc(sizeof(struct genstruct));
  695.       refhead[i] -> name = NULL;
  696.     }
  697.   }
  698.   if (bq) {
  699.     for (i = 0; i < BROWHASHSIZE; i++) {
  700.       browhead[i] = (struct genstruct *)xmalloc(sizeof(struct genstruct));
  701.       browhead[i] -> name = NULL;
  702.     }
  703.   }
  704.   if (Bq) {
  705.     for (i = 0; i < FULLBROWHASHSIZE; i++) {
  706.       fullbrowhead[i] =
  707.     (struct genstruct *)xmalloc(sizeof(struct genstruct));
  708.       fullbrowhead[i] -> name = NULL;
  709.     }
  710.   }
  711.   if (eq) {
  712.     for (i = 0; i < NO_ERRS; i++)
  713.       errors[i] = 0;
  714.   }
  715.   if (oq) {
  716.     for (i = 0; i < DOMHASHSIZE; i++) {
  717.       domainhead[i] = (struct domain *)xmalloc(sizeof(struct domain));
  718.       domainhead[i] -> name = NULL;
  719.     }
  720.     for (i = 0; i < SUBDOMHASHSIZE; i++) {
  721.       subdomhead[i] = (struct domain *)xmalloc(sizeof(struct domain));
  722.       subdomhead[i] -> name = NULL;
  723.     }
  724.     wildsubdomhead = (struct domain *)xmalloc(sizeof(struct domain));
  725.     wildsubdomhead -> id = NULL;
  726.     nwildsubdomhead = (struct domain *)xmalloc(sizeof(struct domain));
  727.     nwildsubdomhead -> id = NULL;
  728.     domainscan();      /* read in all the domains */
  729.   }   /* end if (oq) */
  730.  
  731. }
  732.  
  733. /*** Now for the functions that parse the configuration commands. ***/
  734.  
  735. /* First some warning messages */
  736.  
  737. void configwarning(char *comname, char *inputline)
  738. {  /* a generic warning for the next command */
  739.   if (warnq) {
  740.     fprintf(stderr, "%s: Warning: Not enough arguments to %s command: ignoring line\n", commandname, comname);
  741.     fprintf(stderr, "  %s", inputline);
  742.     if (inputline[strlen(inputline)-1] != '\n')
  743.       fprintf(stderr, "\n", inputline);
  744.   }
  745. }
  746.  
  747. void configwarning2(char *inputline)
  748. {
  749.   if (warnq) {
  750.     fprintf(stderr, "%s: Warning: Discarding illegal configuration command\n",
  751.         commandname);
  752.     fprintf(stderr, "  %s", inputline);
  753.     if (inputline[strlen(inputline)-1] != '\n')
  754.       fprintf(stderr, "\n", inputline);
  755.   }
  756. }
  757.  
  758. void configwarning3(char *comname, char *inputline)
  759. {
  760.   if (warnq) {
  761.     fprintf(stderr, "%s: Warning: Too many arguments to %s command: ignoring end of line\n", commandname, comname);
  762.     fprintf(stderr, "  %s", inputline);
  763.     if (inputline[strlen(inputline)-1] != '\n')
  764.       fprintf(stderr, "\n", inputline);
  765.   }
  766. }
  767.  
  768. /* Next some sub-functions to do things that come up in lots of commands */
  769.  
  770. void addlogfile(struct loglist **p, char name[MAXSTRINGLENGTH],
  771.         char prefix[MAXSTRINGLENGTH])
  772. {
  773.   char *tempstr;
  774.  
  775.   tempstr = strtok(name, ",");
  776.   strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  777.   (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  778.   strncpy((*p) -> prefix, prefix, MAXSTRINGLENGTH - 1);
  779.   (*p) -> prefix[MAXSTRINGLENGTH - 1] = '\0';
  780.   (*p) -> next = (struct loglist *)xmalloc(sizeof(struct loglist));
  781.   *p = (*p) -> next;
  782.   (*p) -> name[0] = '\0';
  783.   while ((tempstr = strtok((char *)NULL, ",")) != NULL) {
  784.     strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  785.     (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  786.     strncpy((*p) -> prefix, prefix, MAXSTRINGLENGTH - 1);
  787.     (*p) -> prefix[MAXSTRINGLENGTH - 1] = '\0';
  788.     (*p) -> next = (struct loglist *)xmalloc(sizeof(struct loglist));
  789.     *p = (*p) -> next;
  790.     (*p) -> name[0] = '\0';
  791.   }
  792. }
  793.  
  794. void include(char *name, struct include **p, int in, char *comname,
  795.          char *inputline, int rc, flag *maskq)
  796. {                          /* put something(s) in an include list */
  797.   char *tempstr;
  798.  
  799.   if (rc < 2)
  800.     configwarning(comname, inputline);
  801.   else {
  802.     if (rc > 2)
  803.       configwarning3(comname, inputline);
  804.     *maskq = ON;
  805.     tempstr = strtok(name, ",");
  806.     strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  807.     (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  808.     (*p) -> in = in;
  809.     (*p) -> next = (struct include *)xmalloc(sizeof(struct include));
  810.     *p = (*p) -> next;
  811.     (*p) -> in = UNSET;
  812.     while ((tempstr = strtok((char *)NULL, ",")) != NULL) {
  813.       strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  814.       (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  815.       (*p) -> in = in;
  816.       (*p) -> next = (struct include *)xmalloc(sizeof(struct include));
  817.       *p = (*p) -> next;
  818.       (*p) -> in = UNSET;
  819.     }
  820.   }
  821. }
  822.  
  823. void configalias(char *from, char *to, struct alias **p, char *comname,
  824.          char *inputline, int rc)
  825. {
  826.   if (rc < 3)
  827.     configwarning(comname, inputline);
  828.   else if (from[0] == '\0' || to[0] == '\0')
  829.     configwarning2(inputline);
  830.   else {
  831.     if (rc > 3)
  832.       configwarning3(comname, inputline);
  833.     strcpy((*p) -> from, from);
  834.     strcpy((*p) -> to, to);
  835.     (*p) -> next = (struct alias *)xmalloc(sizeof(struct alias));
  836.     *p = (*p) -> next;
  837.     (*p) -> from[0] = '\0';
  838.   }
  839. }
  840.  
  841. void fromtodate(char *tstr, struct timestruct *t, flag from,
  842.         char *comname, char *inputline, int rc)
  843. {  /* NB should we put more syntax checking in this function? */
  844.   extern long timecode();      /* in utils.c */
  845.   extern char *strtoupper();   /* in utils.c */
  846.  
  847.   if (rc < 2)
  848.     configwarning(comname, inputline);
  849.   else if (STREQ(strtoupper(tstr), "OFF")) {
  850.     if (from)
  851.       t -> code = -INFINITY;
  852.     else
  853.       t -> code = INFINITY;
  854.   }
  855.   else if ((int)strlen(tstr) < 6)
  856.     configwarning2(inputline);
  857.   else {
  858.     if (rc > 2)
  859.       configwarning3(comname, inputline);
  860.     if (*tstr == '-') {
  861.       t -> year = starttimec.year;
  862.       t -> year -= 10 * (*(++tstr) - '0');
  863.       t -> year -= (*(++tstr) - '0');
  864.     }
  865.     else {
  866.       t -> year = 10 * (*tstr - '0');
  867.       t -> year += (*(++tstr) - '0');
  868.       if (t -> year > 70)   /* (say) */
  869.     t -> year += 1900;
  870.       else
  871.     t -> year += 2000;
  872.     }
  873.     tstr++;
  874.     if (*tstr == '-') {
  875.       t -> monthno = starttimec.monthno;
  876.       t -> monthno -= 10 * (*(++tstr) - '0');
  877.       t -> monthno -= (*(++tstr) - '0');
  878.       while (t -> monthno < 0) {
  879.     t -> monthno += 12;
  880.     t -> year--;
  881.       }
  882.     }
  883.     else if (*tstr == '+') {
  884.       t -> monthno = starttimec.monthno;
  885.       t -> monthno += 10 * (*(++tstr) - '0');
  886.       t -> monthno += (*(++tstr) - '0');
  887.       while (t -> monthno > 11) {
  888.     t -> monthno -= 12;
  889.     t -> year++;
  890.       }
  891.     }
  892.     else {
  893.       t -> monthno = 10 * (*tstr - '0');
  894.       t -> monthno += (*(++tstr) - '0');
  895.       t -> monthno--;  /* prog. months are 1 out from standard */
  896.     }
  897.     tstr++;
  898.     if (*tstr == '-') {
  899.       t -> date = starttimec.date;
  900.       t -> date -= atoi(++tstr);
  901.       while (t -> date <= 0) {
  902.     t -> monthno--;
  903.     if (t -> monthno < 0) {
  904.       t -> monthno += 12;
  905.       t -> year--;
  906.     }
  907.     t -> date += monthlength[t -> monthno] +
  908.       ISLEAPFEB(t -> monthno, t -> year);
  909.       }
  910.     }
  911.     else if (*tstr == '+') {
  912.       t -> date = starttimec.date;
  913.       t -> date += atoi(++tstr);
  914.       while (t -> date > monthlength[t -> monthno] +
  915.          ISLEAPFEB(t -> monthno, t -> year)) {
  916.     t -> date -= monthlength[t -> monthno] +
  917.       ISLEAPFEB(t -> monthno, t -> year);
  918.     t -> monthno++;
  919.     if (t -> monthno > 11) {
  920.       t -> monthno -= 12;
  921.       t -> year++;
  922.     }
  923.       }
  924.     }
  925.     else {
  926.       t -> date = 10 * (*tstr - '0');
  927.       t -> date += (*(++tstr) - '0');
  928.     }
  929.     if (from) {
  930.       t -> hr = 0;
  931.       t -> min = 0;
  932.     }
  933.     else {
  934.       t -> hr = 23;
  935.       t -> min = 59;
  936.     }
  937.     t -> code = timecode(t -> date, t -> monthno, t -> year, t -> hr,
  938.              t -> min);
  939.   }
  940. }
  941.  
  942. void configstr(char *name, char *target, char *comname, char *inputline,
  943.            int rc)  /* NB: name must have size at least MSL */
  944. {
  945.   if (rc < 2)
  946.     configwarning(comname, inputline);
  947.   else {
  948.     if (rc > 2)
  949.       configwarning3(comname, inputline);
  950.     strncpy(target, name, MAXSTRINGLENGTH - 1);
  951.   }
  952. }
  953.  
  954. void configstrlist(char *name, struct stringlist **p, char *comname,
  955.            char *inputline, int rc)
  956. {   /* one or more of a list of strings */ /* NB in configstr() applies */
  957.   char *tempstr;
  958.  
  959.   if (rc < 2)
  960.     configwarning(comname, inputline);
  961.   else {
  962.     if (rc > 2)
  963.       configwarning3(comname, inputline);
  964.     tempstr = strtok(name, ",");
  965.     strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  966.     (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  967.     (*p) -> next = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  968.     *p = (*p) -> next;
  969.     (*p) -> name[0] = '\0';
  970.     while ((tempstr = strtok((char *)NULL, ",")) != NULL) {
  971.       strncpy((*p) -> name, tempstr, MAXSTRINGLENGTH - 1);
  972.       (*p) -> name[MAXSTRINGLENGTH - 1] = '\0';
  973.       (*p) -> next = (struct stringlist *)xmalloc(sizeof(struct stringlist));
  974.       *p = (*p) -> next;
  975.       (*p) -> name[0] = '\0';
  976.     }
  977.   }
  978. }
  979.  
  980.  
  981. void configcols(char *cols, char *target, char *comname, char *inputline,
  982.         int rc)
  983. {                           /* as configstr, but extra length check */
  984.   if (rc < 2)
  985.     configwarning(comname, inputline);
  986.   else {
  987.     if (rc > 2 || (int)strlen(cols) > 4)
  988.       configwarning3(comname, inputline);
  989.     strncpy(target, cols, 4);
  990.   }
  991. }
  992.  
  993. void configchar(char *str, char *target, char *comname, char *inputline,
  994.         int rc)
  995. {                           /* read in a single character */
  996.   if (rc < 2)
  997.     configwarning(comname, inputline);
  998.   else {
  999.     if (rc > 2 || str[1] != '\0')
  1000.       configwarning3(comname, inputline);
  1001.     *target = str[0];
  1002.   }
  1003. }
  1004.  
  1005. void configint(char *number, int *target, char *comname, char *inputline,
  1006.            int rc)
  1007. {
  1008.   if (rc < 2)
  1009.     configwarning(comname, inputline);
  1010.   else {
  1011.     if (rc > 2)
  1012.       configwarning3(comname, inputline);
  1013.     *target = atoi(number);
  1014.   }
  1015. }
  1016.  
  1017. void configsortby(char *method, int *target, char *comname, char *inputline,
  1018.           int rc)
  1019. {
  1020.   extern char *strtoupper();   /* in utils.c */
  1021.  
  1022.   if (rc < 2)
  1023.     configwarning(comname, inputline);
  1024.   else {
  1025.     strtoupper(method);
  1026.     if (STREQ(method, "REQUESTS"))
  1027.       *target = BYREQUESTS;
  1028.     else if (STREQ(method, "BYTES"))
  1029.       *target = BYBYTES;
  1030.     else if (STREQ(method, "ALPHABETICAL"))
  1031.       *target = ALPHABETICAL;
  1032.     else if (STREQ(method, "RANDOM"))
  1033.       *target = RANDOMLY;
  1034.     else
  1035.       configwarning2(inputline);
  1036.   }
  1037. }
  1038.  
  1039. void onoff(char *method, flag *target, char *comname, char *inputline, int rc)
  1040. {
  1041.   extern char *strtoupper();   /* in utils.c */
  1042.  
  1043.   if (rc < 2)
  1044.     configwarning(comname, inputline);
  1045.   else {
  1046.     strtoupper(method);
  1047.     if (STREQ(method, "ON"))
  1048.       *target = ON;
  1049.     else if (STREQ(method, "OFF"))
  1050.       *target = OFF;
  1051.     else
  1052.       configwarning2(inputline);
  1053.   }
  1054. }
  1055.  
  1056. void configline(char inputline[MAXLINELENGTH])  /* process one configline */
  1057. {
  1058.   enum {BADCOMMAND_, FILEALIAS_, HOSTALIAS_, REFALIAS_, FILEINCLUDE_, 
  1059.       FILEEXCLUDE_, HOSTINCLUDE_, HOSTEXCLUDE_, REFINCLUDE_, REFEXCLUDE_,
  1060.       FROM_, TO_, SUBDOMAIN_, WEEKBEGINSON_, APPROXHOSTSIZE_, ISPAGE_,
  1061.       ISNOTPAGE_, SEPCHAR_, REPORTORDER_, WITHARGS_, WITHOUTARGS_,
  1062.       REFWITHARGS_, REFWITHOUTARGS_, NOTSUBDOMAIN_, BASEURL_, DOMCOLS_,
  1063.       HOSTCOLS_, DIRCOLS_, REQCOLS_, REFCOLS_, BROWCOLS_, FULLBROWCOLS_,
  1064.       MONTHCOLS_, DAYCOLS_, FULLDAYCOLS_, WEEKCOLS_, HOURCOLS_,
  1065.       FULLHOURCOLS_, MONTHGRAPH_, DAYGRAPH_, FULLDAYGRAPH_, HOURGRAPH_,
  1066.       FULLHOURGRAPH_, WEEKGRAPH_, GRAPHICAL_, LOGFILE_, CACHEFILE_,
  1067.       REFLOG_, BROWLOG_, ERRLOG_, DOMAINSFILE_, HOSTNAME_, HOSTURL_,
  1068.       HOSTMINREQS_, DOMMINREQS_, SUBDOMMINREQS_, DIRMINREQS_, REQMINREQS_,
  1069.       REFMINREQS_, BROWMINREQS_, FULLBROWMINREQS_, HOSTMINBYTES_,
  1070.       DOMMINBYTES_, SUBDOMMINBYTES_, DIRMINBYTES_, REQMINBYTES_,
  1071.       REFMINBYTES_, BROWMINBYTES_, FULLBROWMINBYTES_, ERRMINOCCS_,
  1072.       REQSORTBY_, DOMSORTBY_, DIRSORTBY_, HOSTSORTBY_, REFSORTBY_,
  1073.       BROWSORTBY_, FULLBROWSORTBY_, MARKCHAR_, PAGEWIDTH_, ALLBACK_,
  1074.       MONTHLYBACK_, FULLHOURLYBACK_, FULLDAILYBACK_, WEEKLYBACK_,
  1075.       MONTHLY_, DAILY_, FULLDAILY_, WEEKLY_, HOURLY_, FULLHOURLY_, DOMAIN_,
  1076.       DIRECTORY_, REQUEST_, FULLHOSTS_, REFERER_, BROWSER_, FULLBROWSER_,
  1077.       STATUS_, ERROR_, DIRLEVEL_, REQTYPE_, PAGELINKS_, COUNTHOSTS_,
  1078.       LASTSEVEN_, WARNINGS_, IMAGEDIR_,
  1079.       MONTHLYUNIT_, HOURLYUNIT_, FULLHOURLYUNIT_, DAILYUNIT_, LOGOURL_,
  1080.       HEADERFILE_, FOOTERFILE_, FULLDAILYUNIT_, WEEKLYUNIT_, ALL_,
  1081.       GENERAL_, OUTPUT_, DEBUG_, RAWBYTES_, UNCOMPRESS_, OUTFILE_}
  1082.   commandtype;   /* final '_'s to avoid clashes with #defines */
  1083.  
  1084.   extern int sscanf_config();  /* in sscanf.c */
  1085.   extern char *strtolower();   /* in utils.c */
  1086.   extern char *strtoupper();   /* in utils.c */
  1087.  
  1088.   char string1[MAXSTRINGLENGTH], string2[MAXSTRINGLENGTH],
  1089.        string3[MAXSTRINGLENGTH];
  1090.   int rc;
  1091.   flag tempflag;
  1092.  
  1093.   rc = sscanf_config(inputline, string1, string2, string3);
  1094.   if (rc > 0) {
  1095.     commandtype = BADCOMMAND_;   /* pessimism :) */
  1096.     strtoupper(string1);
  1097.     if (STREQ(string1, "FILEALIAS"))
  1098.       commandtype = FILEALIAS_;
  1099.     else if (STREQ(string1, "HOSTALIAS"))
  1100.       commandtype = HOSTALIAS_;
  1101.     else if (STREQ(string1, "REFALIAS"))
  1102.       commandtype = REFALIAS_;
  1103.     else if (STREQ(string1, "FILEINCLUDE"))
  1104.       commandtype = FILEINCLUDE_;
  1105.     else if (STREQ(string1, "FILEEXCLUDE"))
  1106.       commandtype = FILEEXCLUDE_;
  1107.     else if (STREQ(string1, "HOSTINCLUDE"))
  1108.       commandtype = HOSTINCLUDE_;
  1109.     else if (STREQ(string1, "HOSTEXCLUDE"))
  1110.       commandtype = HOSTEXCLUDE_;
  1111.     else if (STREQ(string1, "REFINCLUDE"))
  1112.       commandtype = REFINCLUDE_;
  1113.     else if (STREQ(string1, "REFEXCLUDE"))
  1114.       commandtype = REFEXCLUDE_;
  1115.     else if (STREQ(string1, "FROM"))
  1116.       commandtype = FROM_;
  1117.     else if (STREQ(string1, "TO"))
  1118.       commandtype = TO_;
  1119.     else if (STREQ(string1, "SUBDOMAIN"))
  1120.       commandtype = SUBDOMAIN_;
  1121.     else if (STREQ(string1, "WEEKBEGINSON"))
  1122.       commandtype = WEEKBEGINSON_;
  1123.     else if (STREQ(string1, "APPROXHOSTSIZE"))
  1124.       commandtype = APPROXHOSTSIZE_;
  1125.     else if (STREQ(string1, "ISPAGE"))
  1126.       commandtype = ISPAGE_;
  1127.     else if (STREQ(string1, "ISNOTPAGE"))
  1128.       commandtype = ISNOTPAGE_;
  1129.     else if (STREQ(string1, "SEPCHAR"))
  1130.       commandtype = SEPCHAR_;
  1131.     else if (STREQ(string1, "REPORTORDER"))
  1132.       commandtype = REPORTORDER_;
  1133.     else if (STREQ(string1, "WITHARGS"))
  1134.       commandtype = WITHARGS_;
  1135.     else if (STREQ(string1, "WITHOUTARGS"))
  1136.       commandtype = WITHOUTARGS_;
  1137.     else if (STREQ(string1, "REFWITHARGS"))
  1138.       commandtype = REFWITHARGS_;
  1139.     else if (STREQ(string1, "REFWITHOUTARGS"))
  1140.       commandtype = REFWITHOUTARGS_;
  1141.     else if (STREQ(string1, "NOTSUBDOMAIN"))
  1142.       commandtype = NOTSUBDOMAIN_;
  1143.     else if (STREQ(string1, "BASEURL"))
  1144.       commandtype = BASEURL_;
  1145.     else if (STREQ(string1, "DOMCOLS"))
  1146.       commandtype = DOMCOLS_;
  1147.     else if (STREQ(string1, "HOSTCOLS"))
  1148.       commandtype = HOSTCOLS_;
  1149.     else if (STREQ(string1, "DIRCOLS"))
  1150.       commandtype = DIRCOLS_;
  1151.     else if (STREQ(string1, "REQCOLS"))
  1152.       commandtype = REQCOLS_;
  1153.     else if (STREQ(string1, "REFCOLS"))
  1154.       commandtype = REFCOLS_;
  1155.     else if (STREQ(string1, "BROWCOLS"))
  1156.       commandtype = BROWCOLS_;
  1157.     else if (STREQ(string1, "FULLBROWCOLS"))
  1158.       commandtype = FULLBROWCOLS_;
  1159.     else if (STREQ(string1, "MONTHCOLS"))
  1160.       commandtype = MONTHCOLS_;
  1161.     else if (STREQ(string1, "DAYCOLS"))
  1162.       commandtype = DAYCOLS_;
  1163.     else if (STREQ(string1, "FULLDAYCOLS"))
  1164.       commandtype = FULLDAYCOLS_;
  1165.     else if (STREQ(string1, "WEEKCOLS"))
  1166.       commandtype = WEEKCOLS_;
  1167.     else if (STREQ(string1, "HOURCOLS"))
  1168.       commandtype = HOURCOLS_;
  1169.     else if (STREQ(string1, "FULLHOURCOLS"))
  1170.       commandtype = FULLHOURCOLS_;
  1171.     else if (STREQ(string1, "MONTHGRAPH"))
  1172.       commandtype = MONTHGRAPH_;
  1173.     else if (STREQ(string1, "DAYGRAPH"))
  1174.       commandtype = DAYGRAPH_;
  1175.     else if (STREQ(string1, "FULLDAYGRAPH"))
  1176.       commandtype = FULLDAYGRAPH_;
  1177.     else if (STREQ(string1, "HOURGRAPH"))
  1178.       commandtype = HOURGRAPH_;
  1179.     else if (STREQ(string1, "FULLHOURGRAPH"))
  1180.       commandtype = FULLHOURGRAPH_;
  1181.     else if (STREQ(string1, "WEEKGRAPH"))
  1182.       commandtype = WEEKGRAPH_;
  1183.     else if (STREQ(string1, "GRAPHICAL"))
  1184.       commandtype = GRAPHICAL_;
  1185.     else if (STREQ(string1, "LOGFILE"))
  1186.       commandtype = LOGFILE_;
  1187.     else if (STREQ(string1, "CACHEFILE"))
  1188.       commandtype = CACHEFILE_;
  1189.     else if (STREQ(string1, "REFLOG"))
  1190.       commandtype = REFLOG_;
  1191.     else if (STREQ(string1, "BROWLOG"))
  1192.       commandtype = BROWLOG_;
  1193.     else if (STREQ(string1, "ERRLOG"))
  1194.       commandtype = ERRLOG_;
  1195.     else if (STREQ(string1, "DOMAINSFILE"))
  1196.       commandtype = DOMAINSFILE_;
  1197.     else if (STREQ(string1, "HOSTNAME"))
  1198.       commandtype = HOSTNAME_;
  1199.     else if (STREQ(string1, "HOSTURL"))
  1200.       commandtype = HOSTURL_;
  1201.     else if (STREQ(string1, "HOSTMINREQS"))
  1202.       commandtype = HOSTMINREQS_;
  1203.     else if (STREQ(string1, "DOMMINREQS"))
  1204.       commandtype = DOMMINREQS_;
  1205.     else if (STREQ(string1, "SUBDOMMINREQS"))
  1206.       commandtype = SUBDOMMINREQS_;
  1207.     else if (STREQ(string1, "DIRMINREQS"))
  1208.       commandtype = DIRMINREQS_;
  1209.     else if (STREQ(string1, "REQMINREQS"))
  1210.       commandtype = REQMINREQS_;
  1211.     else if (STREQ(string1, "REFMINREQS"))
  1212.       commandtype = REFMINREQS_;
  1213.     else if (STREQ(string1, "BROWMINREQS"))
  1214.       commandtype = BROWMINREQS_;
  1215.     else if (STREQ(string1, "FULLBROWMINREQS"))
  1216.       commandtype = FULLBROWMINREQS_;
  1217.     else if (STREQ(string1, "HOSTMINBYTES"))
  1218.       commandtype = HOSTMINBYTES_;
  1219.     else if (STREQ(string1, "DOMMINBYTES"))
  1220.     commandtype = DOMMINBYTES_;
  1221.     else if (STREQ(string1, "SUBDOMMINBYTES"))
  1222.       commandtype = SUBDOMMINBYTES_;
  1223.     else if (STREQ(string1, "DIRMINBYTES"))
  1224.       commandtype = DIRMINBYTES_;
  1225.     else if (STREQ(string1, "REQMINBYTES"))
  1226.       commandtype = REQMINBYTES_;
  1227.     else if (STREQ(string1, "REFMINBYTES"))
  1228.       commandtype = REFMINBYTES_;
  1229.     else if (STREQ(string1, "BROWMINBYTES"))
  1230.       commandtype = BROWMINBYTES_;
  1231.     else if (STREQ(string1, "FULLBROWMINBYTES"))
  1232.       commandtype = FULLBROWMINBYTES_;
  1233.     else if (STREQ(string1, "ERRMINOCCS"))
  1234.       commandtype = ERRMINOCCS_;
  1235.     else if (STREQ(string1, "REQSORTBY"))
  1236.       commandtype = REQSORTBY_;
  1237.     else if (STREQ(string1, "DOMSORTBY"))
  1238.       commandtype = DOMSORTBY_;
  1239.     else if (STREQ(string1, "DIRSORTBY"))
  1240.       commandtype = DIRSORTBY_;
  1241.     else if (STREQ(string1, "HOSTSORTBY"))
  1242.       commandtype = HOSTSORTBY_;
  1243.     else if (STREQ(string1, "MARKCHAR"))
  1244.       commandtype = MARKCHAR_;
  1245.     else if (STREQ(string1, "PAGEWIDTH"))
  1246.       commandtype = PAGEWIDTH_;
  1247.     else if (STREQ(string1, "ALLBACK"))
  1248.       commandtype = ALLBACK_;
  1249.     else if (STREQ(string1, "MONTHLYBACK"))
  1250.       commandtype = MONTHLYBACK_;
  1251.     else if (STREQ(string1, "FULLHOURLYBACK"))
  1252.       commandtype = FULLHOURLYBACK_;
  1253.     else if (STREQ(string1, "FULLDAILYBACK"))
  1254.       commandtype = FULLDAILYBACK_;
  1255.     else if (STREQ(string1, "WEEKLYBACK"))
  1256.       commandtype = WEEKLYBACK_;
  1257.     else if (STREQ(string1, "MONTHLY"))
  1258.       commandtype = MONTHLY_;
  1259.     else if (STREQ(string1, "DAILY"))
  1260.       commandtype = DAILY_;
  1261.     else if (STREQ(string1, "FULLDAILY"))
  1262.       commandtype = FULLDAILY_;
  1263.     else if (STREQ(string1, "WEEKLY"))
  1264.       commandtype = WEEKLY_;
  1265.     else if (STREQ(string1, "HOURLY"))
  1266.       commandtype = HOURLY_;
  1267.     else if (STREQ(string1, "FULLHOURLY"))
  1268.       commandtype = FULLHOURLY_;
  1269.     else if (STREQ(string1, "DOMAIN"))
  1270.       commandtype = DOMAIN_;
  1271.     else if (STREQ(string1, "DIRECTORY"))
  1272.       commandtype = DIRECTORY_;
  1273.     else if (STREQ(string1, "REQUEST"))
  1274.       commandtype = REQUEST_;
  1275.     else if (STREQ(string1, "FULLHOSTS"))
  1276.       commandtype = FULLHOSTS_;
  1277.     else if (STREQ(string1, "REFERER"))
  1278.       commandtype = REFERER_;
  1279.     else if (STREQ(string1, "BROWSER"))
  1280.       commandtype = BROWSER_;
  1281.     else if (STREQ(string1, "FULLBROWSER"))
  1282.       commandtype = FULLBROWSER_;
  1283.     else if (STREQ(string1, "STATUS"))
  1284.       commandtype = STATUS_;
  1285.     else if (STREQ(string1, "ERROR"))
  1286.       commandtype = ERROR_;
  1287.     else if (STREQ(string1, "DIRLEVEL"))
  1288.       commandtype = DIRLEVEL_;
  1289.     else if (STREQ(string1, "REQTYPE"))
  1290.       commandtype = REQTYPE_;
  1291.     else if (STREQ(string1, "PAGELINKS"))
  1292.       commandtype = PAGELINKS_;
  1293.     else if (STREQ(string1, "COUNTHOSTS"))
  1294.       commandtype = COUNTHOSTS_;
  1295.     else if (STREQ(string1, "LASTSEVEN"))
  1296.       commandtype = LASTSEVEN_;
  1297.     else if (STREQ(string1, "WARNINGS"))
  1298.       commandtype = WARNINGS_;
  1299.     else if (STREQ(string1, "IMAGEDIR"))
  1300.       commandtype = IMAGEDIR_;
  1301.     else if (STREQ(string1, "MONTHLYUNIT"))
  1302.       commandtype = MONTHLYUNIT_;
  1303.     else if (STREQ(string1, "HOURLYUNIT"))
  1304.       commandtype = HOURLYUNIT_;
  1305.     else if (STREQ(string1, "FULLHOURLYUNIT"))
  1306.       commandtype = FULLHOURLYUNIT_;
  1307.     else if (STREQ(string1, "DAILYUNIT"))
  1308.       commandtype = DAILYUNIT_;
  1309.     else if (STREQ(string1, "FULLDAILYUNIT"))
  1310.       commandtype = FULLDAILYUNIT_;
  1311.     else if (STREQ(string1, "WEEKLYUNIT"))
  1312.       commandtype = WEEKLYUNIT_;
  1313.     else if (STREQ(string1, "LOGOURL"))
  1314.       commandtype = LOGOURL_;
  1315.     else if (STREQ(string1, "HEADERFILE"))
  1316.       commandtype = HEADERFILE_;
  1317.     else if (STREQ(string1, "FOOTERFILE"))
  1318.       commandtype = FOOTERFILE_;
  1319.     else if (STREQ(string1, "ALL"))
  1320.       commandtype = ALL_;
  1321.     else if (STREQ(string1, "GENERAL"))
  1322.       commandtype = GENERAL_;
  1323.     else if (STREQ(string1, "OUTPUT"))
  1324.       commandtype = OUTPUT_;
  1325.     else if (STREQ(string1, "DEBUG"))
  1326.       commandtype = DEBUG_;
  1327.     else if (STREQ(string1, "RAWBYTES"))
  1328.       commandtype = RAWBYTES_;
  1329.     else if (STREQ(string1, "UNCOMPRESS"))
  1330.       commandtype = UNCOMPRESS_;
  1331.     else if (STREQ(string1, "OUTFILE"))
  1332.       commandtype = OUTFILE_;
  1333.     
  1334.     switch(commandtype) {
  1335.     case (BADCOMMAND_):
  1336.       configwarning2(inputline);
  1337.       break;
  1338.     case (FILEALIAS_):
  1339.       configalias(string2, string3, &filealiasp, string1, inputline, rc);
  1340.       break;
  1341.     case (HOSTALIAS_):
  1342.       configalias(strtolower(string2), strtolower(string3), &hostaliasp,
  1343.           string1, inputline, rc);
  1344.       break;
  1345.     case (REFALIAS_):
  1346.       configalias(string2, string3, &refaliasp, string1, inputline, rc);
  1347.       break;
  1348.     case (FILEINCLUDE_):
  1349.       include(string2, &wantfilep, TRUE, string1, inputline, rc, &filemaskq);
  1350.       break;
  1351.     case (FILEEXCLUDE_):
  1352.       include(string2, &wantfilep, FALSE, string1, inputline, rc, &filemaskq);
  1353.       break;
  1354.     case (HOSTINCLUDE_):
  1355.       include(string2,& wanthostp, TRUE, string1, inputline, rc, &hostmaskq);
  1356.       break;
  1357.     case (HOSTEXCLUDE_):
  1358.       include(string2, &wanthostp, FALSE, string1, inputline, rc, &hostmaskq);
  1359.       break;
  1360.     case (REFINCLUDE_):
  1361.       include(string2, &wantrefp, TRUE, string1, inputline, rc, &refmaskq);
  1362.       break;
  1363.     case (REFEXCLUDE_):
  1364.       include(string2, &wantrefp, FALSE, string1, inputline, rc, &refmaskq);
  1365.       break;
  1366.     case (FROM_):
  1367.       fromtodate(string2, &fromtime, TRUE, string1, inputline, rc);
  1368.     break;
  1369.     case (TO_):
  1370.       fromtodate(string2, &totime, FALSE, string1, inputline, rc);
  1371.       break;
  1372.     case (SUBDOMAIN_):
  1373.       if (string2[0] == '\0')
  1374.     configwarning2(inputline);
  1375.       else if (rc < 2)
  1376.     configwarning(string1, inputline);
  1377.       else {
  1378.     if (rc > 3 ||
  1379.         (rc == 3 && (string2[0] == '*' || 
  1380.              string2[(int)strlen(string2) - 1] == '*' ||
  1381.              string2[0] == '%')))
  1382.       configwarning3(string1, inputline);
  1383.     strcpy(subdomp -> from, string2);
  1384.     if (rc == 2 || string2[0] == '*' ||
  1385.         string2[(int)strlen(string2) - 1] == '*' || string2[0] == '%')
  1386.       strcpy(subdomp -> to, "?");
  1387.     else
  1388.       strcpy(subdomp -> to, string3);
  1389.     subdomp -> next =
  1390.       (struct alias *)xmalloc(sizeof(struct alias));
  1391.     subdomp = subdomp -> next;
  1392.     subdomp -> from[0] = '\0';
  1393.       }
  1394.       break;
  1395.     case (WEEKBEGINSON_):
  1396.       if (rc < 2)
  1397.     configwarning(string1, inputline);
  1398.       else {
  1399.     strtoupper(string2);
  1400.     if (STREQ(string2, "SUNDAY"))
  1401.       weekbeginson = SUNDAY;
  1402.     else if (STREQ(string2, "MONDAY"))
  1403.       weekbeginson = MONDAY;
  1404.     else if (STREQ(string2, "TUESDAY"))
  1405.       weekbeginson = TUESDAY;
  1406.     else if (STREQ(string2, "WEDNESDAY"))
  1407.       weekbeginson = WEDNESDAY;
  1408.     else if (STREQ(string2, "THURSDAY"))
  1409.       weekbeginson = THURSDAY;
  1410.     else if (STREQ(string2, "FRIDAY"))
  1411.       weekbeginson = FRIDAY;
  1412.     else if (STREQ(string2, "SATURDAY"))
  1413.       weekbeginson = SATURDAY;
  1414.     else
  1415.       configwarning2(inputline);
  1416.       }
  1417.       break;
  1418.     case (APPROXHOSTSIZE_):
  1419.       if (rc < 2)
  1420.     configwarning(string1, inputline);
  1421.       else {
  1422.     if (rc > 2)
  1423.       configwarning3(string1, inputline);
  1424.     approxhostsize = atoi(string2);
  1425.     if (approxhostsize <= 0)
  1426.       configwarning2(inputline);
  1427.       }
  1428.       break;
  1429.     case (ISPAGE_):
  1430.       include(string2, &ispagep, TRUE, string1, inputline, rc, &tempflag);
  1431.       break;
  1432.     case (ISNOTPAGE_):
  1433.       include(string2, &ispagep, FALSE, string1, inputline, rc, &tempflag);
  1434.       break;
  1435.     case (SEPCHAR_):
  1436.       if (rc < 2)
  1437.     configwarning(string1, inputline);
  1438.       else {
  1439.     if (rc > 2 || (string2[0] != '\0' && string2[1] != '\0'))
  1440.       configwarning3(string1, inputline);
  1441.     sepchar = string2[0];
  1442.       }
  1443.     break;
  1444.     case (REPORTORDER_):
  1445.       if (rc < 2)
  1446.     configwarning(string1, inputline);
  1447.       else {
  1448.     if (rc > 2 || (int)strlen(string2) > 15)
  1449.       configwarning3(string1, inputline);
  1450.     strncpy(reportorder, string2, 15);
  1451.     }
  1452.       break;
  1453.     case (WITHARGS_):
  1454.       include(string2, &noexpandp, FALSE, string1, inputline, rc, &tempflag);
  1455.       break;
  1456.     case (WITHOUTARGS_):
  1457.       include(string2, &noexpandp, TRUE, string1, inputline, rc, &tempflag);
  1458.       break;
  1459.     case (REFWITHARGS_):
  1460.       include(string2, &refexpandp, TRUE, string1, inputline, rc, &tempflag);
  1461.     break;
  1462.     case (REFWITHOUTARGS_):
  1463.       include(string2, &refexpandp, FALSE, string1, inputline, rc, &tempflag);
  1464.       break;
  1465.     case (NOTSUBDOMAIN_):
  1466.       if (rc < 2)
  1467.     configwarning(string1, inputline);
  1468.       else {
  1469.     if (rc > 2)
  1470.       configwarning3(string1, inputline);
  1471.     for (subdomtempp = subdomshead; subdomtempp -> from[0] != '\0' &&
  1472.          !STREQ(subdomtempp -> from, string2);
  1473.          subdomtempp = subdomtempp -> next)
  1474.       ;     /* run to the subdomain we want to remove */
  1475.     if (subdomtempp -> from[0] != '\0')
  1476.       subdomtempp -> from[0] = '?';   /* mark that we don't want it */
  1477.       }
  1478.       break;
  1479.     case (BASEURL_):
  1480.       configstr(string2, baseurl, string1, inputline, rc);
  1481.       break;
  1482.     case (DOMCOLS_):
  1483.       configcols(string2, domcols, string1, inputline, rc);
  1484.       break;
  1485.     case (HOSTCOLS_):
  1486.       configcols(string2, hostcols, string1, inputline, rc);
  1487.       break;
  1488.     case (DIRCOLS_):
  1489.       configcols(string2, dircols, string1, inputline, rc);
  1490.       break;
  1491.     case (REQCOLS_):
  1492.       configcols(string2, reqcols, string1, inputline, rc);
  1493.       break;
  1494.     case (REFCOLS_):
  1495.       configcols(string2, refcols, string1, inputline, rc);
  1496.       break;
  1497.     case (BROWCOLS_):
  1498.       configcols(string2, browcols, string1, inputline, rc);
  1499.       break;
  1500.     case (FULLBROWCOLS_):
  1501.       configcols(string2, fullbrowcols, string1, inputline, rc);
  1502.       break;
  1503.     case (MONTHCOLS_):
  1504.       configcols(string2, monthcols, string1, inputline, rc);
  1505.       break;
  1506.     case (DAYCOLS_):
  1507.       configcols(string2, daycols, string1, inputline, rc);
  1508.       break;
  1509.     case (FULLDAYCOLS_):
  1510.       configcols(string2, fulldaycols, string1, inputline, rc);
  1511.       break;
  1512.     case (WEEKCOLS_):
  1513.       configcols(string2, weekcols, string1, inputline, rc);
  1514.       break;
  1515.     case (HOURCOLS_):
  1516.       configcols(string2, hourcols, string1, inputline, rc);
  1517.       break;
  1518.     case (FULLHOURCOLS_):
  1519.       configcols(string2, fullhourcols, string1, inputline, rc);
  1520.       break;
  1521.     case (MONTHGRAPH_):
  1522.       configchar(string2, &monthgraph, string1, inputline, rc);
  1523.       break;
  1524.     case (DAYGRAPH_):
  1525.       configchar(string2, &daygraph, string1, inputline, rc);
  1526.       break;
  1527.     case (FULLDAYGRAPH_):
  1528.       configchar(string2, &fulldaygraph, string1, inputline, rc);
  1529.       break;
  1530.     case (HOURGRAPH_):
  1531.       configchar(string2, &hourgraph, string1, inputline, rc);
  1532.       break;
  1533.     case (FULLHOURGRAPH_):
  1534.       configchar(string2, &fullhourgraph, string1, inputline, rc);
  1535.       break;
  1536.     case (WEEKGRAPH_):
  1537.       configchar(string2, &weekgraph, string1, inputline, rc);
  1538.       break;
  1539.     case (GRAPHICAL_):
  1540.       onoff(string2, &graphical, string1, inputline, rc);
  1541.       break;
  1542.     case (LOGFILE_):
  1543.       if (rc < 2)
  1544.     configwarning(string1, inputline);
  1545.       else if (STREQ(string2, "none")) {
  1546.     logfilep = logfilehead;
  1547.     logfilehead -> name[0] = '\0';
  1548.       }
  1549.       else if (rc == 2)
  1550.     addlogfile(&logfilep, string2, "");
  1551.       else {
  1552.     addlogfile(&logfilep, string2, string3);
  1553.     if (rc > 3)
  1554.       configwarning3(string1, inputline);
  1555.       }
  1556.       break;
  1557.     case (CACHEFILE_):
  1558.       if (STREQ(string2, "none")) {
  1559.     cachefilep = cachefilehead;
  1560.     cachefilehead -> name[0] = '\0';
  1561.       }
  1562.       else
  1563.     configstrlist(string2, &cachefilep, string1, inputline, rc);
  1564.       break;
  1565.     case (REFLOG_):
  1566.       if (STREQ(string2, "none")) {
  1567.     reflogp = refloghead;
  1568.     refloghead -> name[0] = '\0';
  1569.       }
  1570.       else
  1571.     configstrlist(string2, &reflogp, string1, inputline, rc);
  1572.       break;
  1573.     case (BROWLOG_):
  1574.       if (STREQ(string2, "none")) {
  1575.     browlogp = browloghead;
  1576.     browloghead -> name[0] = '\0';
  1577.       }
  1578.       else
  1579.     configstrlist(string2, &browlogp, string1, inputline, rc);
  1580.       break;
  1581.     case (ERRLOG_):
  1582.     if (STREQ(string2, "none")) {
  1583.       errlogp = errloghead;
  1584.       errloghead -> name[0] = '\0';
  1585.     }
  1586.     else
  1587.       configstrlist(string2, &errlogp, string1, inputline, rc);
  1588.       break;
  1589.     case (DOMAINSFILE_):
  1590.       configstr(string2, domainsfile, string1, inputline, rc);
  1591.       break;
  1592.     case (HOSTNAME_):
  1593.       configstr(string2, hostname, string1, inputline, rc);
  1594.       break;
  1595.     case (HOSTURL_):
  1596.       configstr(string2, hosturl, string1, inputline, rc);
  1597.       break;
  1598.     case (HOSTMINREQS_):
  1599.       configstr(string2, hostminreqstr, string1, inputline, rc);
  1600.       break;
  1601.     case (DOMMINREQS_):
  1602.       configstr(string2, domminreqstr, string1, inputline, rc);
  1603.       break;
  1604.     case (SUBDOMMINREQS_):
  1605.       configstr(string2, subdomminreqstr, string1, inputline, rc);
  1606.       break;
  1607.     case (DIRMINREQS_):
  1608.       configstr(string2, dirminreqstr, string1, inputline, rc);
  1609.       break;
  1610.     case (REQMINREQS_):
  1611.       configstr(string2, urlminreqstr, string1, inputline, rc);
  1612.       break;
  1613.     case (REFMINREQS_):
  1614.       configstr(string2, refminreqstr, string1, inputline, rc);
  1615.       break;
  1616.     case (BROWMINREQS_):
  1617.       configstr(string2, browminreqstr, string1, inputline, rc);
  1618.       break;
  1619.     case (FULLBROWMINREQS_):
  1620.       configstr(string2, fullbrowminreqstr, string1, inputline, rc);
  1621.       break;
  1622.     case (HOSTMINBYTES_):
  1623.       configstr(string2, hostminbytestr, string1, inputline, rc);
  1624.     break;
  1625.     case (DOMMINBYTES_):
  1626.       configstr(string2, domminbytestr, string1, inputline, rc);
  1627.       break;
  1628.     case (SUBDOMMINBYTES_):
  1629.       configstr(string2, subdomminbytestr, string1, inputline, rc);
  1630.       break;
  1631.     case (DIRMINBYTES_):
  1632.       configstr(string2, dirminbytestr, string1, inputline, rc);
  1633.       break;
  1634.     case (REQMINBYTES_):
  1635.       configstr(string2, urlminbytestr, string1, inputline, rc);
  1636.       break;
  1637.     case (REFMINBYTES_):
  1638.       configstr(string2, refminbytestr, string1, inputline, rc);
  1639.       break;
  1640.     case (BROWMINBYTES_):
  1641.       configstr(string2, browminbytestr, string1, inputline, rc);
  1642.       break;
  1643.     case (FULLBROWMINBYTES_):
  1644.       configstr(string2, fullbrowminbytestr, string1, inputline, rc);
  1645.       break;
  1646.     case (ERRMINOCCS_):
  1647.       configint(string2, &errminreqs, string1, inputline, rc);
  1648.       break;
  1649.     case (REQSORTBY_):
  1650.       configsortby(string2, &reqsortby, string1, inputline, rc);
  1651.       break;
  1652.     case (DOMSORTBY_):
  1653.       configsortby(string2, &domsortby, string1, inputline, rc);
  1654.       break;
  1655.     case (DIRSORTBY_):
  1656.       configsortby(string2, &dirsortby, string1, inputline, rc);
  1657.       break;
  1658.     case (HOSTSORTBY_):
  1659.       configsortby(string2, &hostsortby, string1, inputline, rc);
  1660.       break;
  1661.     case (REFSORTBY_):
  1662.       configsortby(string2, &refsortby, string1, inputline, rc);
  1663.       break;
  1664.     case (BROWSORTBY_):
  1665.       configsortby(string2, &browsortby, string1, inputline, rc);
  1666.       break;
  1667.     case (FULLBROWSORTBY_):
  1668.       configsortby(string2, &fullbrowsortby, string1, inputline, rc);
  1669.       break;
  1670.     case (MARKCHAR_):
  1671.       if (rc < 2)
  1672.     configwarning(string1, inputline);
  1673.       else {
  1674.     if (rc > 2 || string2[1] != '\0')
  1675.       configwarning3(string1, inputline);
  1676.     markchar = string2[0];
  1677.       }
  1678.       break;
  1679.     case (PAGEWIDTH_):
  1680.       if (rc < 2)
  1681.     configwarning(string1, inputline);
  1682.       else {
  1683.     if (rc > 2)
  1684.       configwarning3(string1, inputline);
  1685.     pagewidth = atoi(string2);
  1686.     if (pagewidth < MINPAGEWIDTH || pagewidth > MAXPAGEWIDTH) {
  1687.       fprintf(stderr, "%s: Page width should be between %d and %d\n",
  1688.           commandname, MINPAGEWIDTH, MAXPAGEWIDTH);
  1689.       configwarning2(inputline);
  1690.       pagewidth = PAGEWIDTH;
  1691.     }
  1692.       }
  1693.       break;
  1694.     case (ALLBACK_):  /* onoff() extended */
  1695.       if (rc < 2)
  1696.     configwarning(string1, inputline);
  1697.       else {
  1698.     strtoupper(string2);
  1699.     if (STREQ(string2, "ON")) {
  1700.       mback = ON;
  1701.       Hback = ON;
  1702.       Wback = ON;
  1703.       Dback = ON;
  1704.     }
  1705.     else if (STREQ(string2, "OFF")) {
  1706.       mback = OFF;
  1707.       Hback = OFF;
  1708.       Wback = OFF;
  1709.       Dback = OFF;
  1710.     }
  1711.     else
  1712.       configwarning2(inputline);
  1713.       }
  1714.       break;
  1715.     case (MONTHLYBACK_):
  1716.       onoff(string2, &mback, string1, inputline, rc);
  1717.       break;
  1718.     case (FULLHOURLYBACK_):
  1719.       onoff(string2, &Hback, string1, inputline, rc);
  1720.       break;
  1721.     case (FULLDAILYBACK_):
  1722.       onoff(string2, &Dback, string1, inputline, rc);
  1723.       break;
  1724.     case (WEEKLYBACK_):
  1725.       onoff(string2, &Wback, string1, inputline, rc);
  1726.       break;
  1727.     case (MONTHLY_):
  1728.       onoff(string2, &mq, string1, inputline, rc);
  1729.       break;
  1730.     case (DAILY_):
  1731.       onoff(string2, &dq, string1, inputline, rc);
  1732.       break;
  1733.     case (FULLDAILY_):
  1734.       onoff(string2, &Dq, string1, inputline, rc);
  1735.       break;
  1736.     case (HOURLY_):
  1737.       onoff(string2, &hq, string1, inputline, rc);
  1738.       break;
  1739.     case (FULLHOURLY_):
  1740.       onoff(string2, &Hq, string1, inputline, rc);
  1741.       break;
  1742.     case (WEEKLY_):
  1743.       onoff(string2, &Wq, string1, inputline, rc);
  1744.       break;
  1745.     case (DOMAIN_):
  1746.       onoff(string2, &oq, string1, inputline, rc);
  1747.       break;
  1748.     case (FULLHOSTS_):
  1749.       onoff(string2, &Sq, string1, inputline, rc);
  1750.       break;
  1751.     case (DIRECTORY_):
  1752.       onoff(string2, &iq, string1, inputline, rc);
  1753.       break;
  1754.     case (REQUEST_):
  1755.       onoff(string2, &rq, string1, inputline, rc);
  1756.       break;
  1757.     case (REFERER_):
  1758.       onoff(string2, &fq, string1, inputline, rc);
  1759.       break;
  1760.     case (BROWSER_):
  1761.       onoff(string2, &bq, string1, inputline, rc);
  1762.       break;
  1763.     case (FULLBROWSER_):
  1764.       onoff(string2, &Bq, string1, inputline, rc);
  1765.       break;
  1766.     case (STATUS_):
  1767.       onoff(string2, &cq, string1, inputline, rc);
  1768.       break;
  1769.     case (ERROR_):
  1770.       onoff(string2, &eq, string1, inputline, rc);
  1771.       break;
  1772.     case (ALL_):
  1773.       if (rc < 2)
  1774.     configwarning(string1, inputline);
  1775.       else {
  1776.     strtoupper(string2);
  1777.     if (STREQ(string2, "ON")) {
  1778.       mq = ON;
  1779.       Wq = ON;
  1780.       dq = ON;
  1781.       Dq = ON;
  1782.       hq = ON;
  1783.       oq = ON;
  1784.       Sq = ON;
  1785.       iq = ON;
  1786.       rq = ON;
  1787.       fq = ON;
  1788.       bq = ON;
  1789.       Bq = ON;
  1790.       cq = ON;
  1791.       eq = ON;
  1792.     }
  1793.     else if (STREQ(string2, "OFF"))  {
  1794.       mq = OFF;
  1795.       Wq = OFF;
  1796.       dq = OFF;
  1797.       Dq = OFF;
  1798.       hq = OFF;
  1799.       oq = OFF;
  1800.       Sq = OFF;
  1801.       iq = OFF;
  1802.       rq = OFF;
  1803.       fq = OFF;
  1804.       bq = OFF;
  1805.       Bq = OFF;
  1806.       cq = OFF;
  1807.       eq = OFF;
  1808.     }
  1809.     else
  1810.       configwarning2(inputline);
  1811.       }
  1812.       break;
  1813.     case (GENERAL_):
  1814.       onoff(string2, &xq, string1, inputline, rc);
  1815.       break;
  1816.     case (DIRLEVEL_):
  1817.       configint(string2, &dirlevel, string1, inputline, rc);
  1818.       break;
  1819.     case (REQTYPE_):
  1820.       if (rc < 2)
  1821.     configwarning(string1, inputline);
  1822.       else {
  1823.     strtoupper(string2);
  1824.     if (STREQ(string2, "PAGES"))
  1825.       reqtype = PAGES;
  1826.     else if (STREQ(string2, "ALL"))
  1827.       reqtype = ALL;
  1828.     else
  1829.       configwarning2(inputline);
  1830.       }
  1831.       break;
  1832.     case (PAGELINKS_):
  1833.       if (rc < 2)
  1834.     configwarning(string1, inputline);
  1835.       else {
  1836.     strtoupper(string2);
  1837.     if (STREQ(string2, "ON"))
  1838.       kq = ON;
  1839.     else if (STREQ(string2, "OFF"))
  1840.       kq = OFF;
  1841.     else if (STREQ(string2, "ALL"))
  1842.       kq = ALL;
  1843.     else
  1844.       configwarning2(inputline);
  1845.       }
  1846.       break;
  1847.     case (COUNTHOSTS_):
  1848.       if (rc < 2)
  1849.     configwarning(string1, inputline);
  1850.       else {
  1851.     strtoupper(string2);
  1852.     if (STREQ(string2, "ON"))
  1853.       sq = ON;
  1854.     else if (STREQ(string2, "OFF"))
  1855.       sq = OFF;
  1856.     else if (STREQ(string2, "APPROX"))
  1857.       sq = APPROX;
  1858.     else
  1859.       configwarning2(inputline);
  1860.       }
  1861.       break;
  1862.     case (LASTSEVEN_):
  1863.       onoff(string2, &q7, string1, inputline, rc);
  1864.       break;
  1865.     case (WARNINGS_):
  1866.       onoff(string2, &warnq, string1, inputline, rc);
  1867.       break;
  1868.     case (IMAGEDIR_):
  1869.       configstr(string2, imagedir, string1, inputline, rc);
  1870.       break;
  1871.     case (MONTHLYUNIT_):
  1872.       configint(string2, &monthlyunit, string1, inputline, rc);      
  1873.       break;
  1874.     case (HOURLYUNIT_):
  1875.       configint(string2, &hourlyunit, string1, inputline, rc);      
  1876.       break;
  1877.     case (FULLHOURLYUNIT_):
  1878.       configint(string2, &fullhourlyunit, string1, inputline, rc);      
  1879.       break;
  1880.     case (DAILYUNIT_):
  1881.       configint(string2, &dailyunit, string1, inputline, rc);      
  1882.       break;
  1883.     case (FULLDAILYUNIT_):
  1884.       configint(string2, &fulldailyunit, string1, inputline, rc);      
  1885.       break;
  1886.     case (WEEKLYUNIT_):
  1887.       configint(string2, &weeklyunit, string1, inputline, rc);      
  1888.       break;
  1889.     case (LOGOURL_):
  1890.       configstr(string2, logourl, string1, inputline, rc);
  1891.       break;
  1892.     case (HEADERFILE_):
  1893.       configstr(string2, headerfile, string1, inputline, rc);
  1894.       break;
  1895.     case (FOOTERFILE_):
  1896.       configstr(string2, footerfile, string1, inputline, rc);
  1897.       break;
  1898.     case (OUTPUT_):
  1899.       if (rc < 2)
  1900.     configwarning(string1, inputline);
  1901.       else {
  1902.     strtoupper(string2);
  1903.     if (STREQ(string2, "ASCII"))
  1904.       aq = ASCII;
  1905.     else if (STREQ(string2, "HTML"))
  1906.       aq = HTML;
  1907.     else if (STREQ(string2, "CACHE"))
  1908.       aq = CACHE;
  1909.     else
  1910.       configwarning2(inputline);
  1911.       }
  1912.       break;
  1913.     case (DEBUG_):
  1914.       configint(string2, &debug, string1, inputline, rc);      
  1915.       break;
  1916.     case (RAWBYTES_):
  1917.       onoff(string2, &rawbytes, string1, inputline, rc);
  1918.       break;
  1919.     case (UNCOMPRESS_):
  1920.       if (rc < 3)
  1921.     configwarning(string1, inputline);
  1922.       else {
  1923.     addlogfile(&uncompressp, string2, string3);
  1924.     if (rc > 3)
  1925.       configwarning3(string1, inputline);
  1926.       }
  1927.       break;
  1928.     case (OUTFILE_):
  1929.       configstr(string2, outfile, string1, inputline, rc);
  1930.       break;
  1931.     }
  1932.   }
  1933. }
  1934.  
  1935. flag config(char *filename)
  1936. {
  1937.  
  1938.   FILE *cf;
  1939.   char inputline[MAXLINELENGTH];
  1940.  
  1941.   if (STREQ(filename, "none"))
  1942.     return(0);
  1943.   else if (STREQ(filename, "stdin") || STREQ(filename, "-"))
  1944.     cf = stdin;
  1945.   else
  1946.     cf = fopen(filename, "r");
  1947.  
  1948.   if (cf == NULL) {
  1949.     if (warnq)
  1950.       fprintf(stderr, "%s: Warning: Failed to open configuration file \"%s\": ignoring it\n", commandname, filename);
  1951.     return(1);
  1952.   }
  1953.  
  1954.   else {  /* we can read the config. file */
  1955.     while (fgets(inputline, MAXLINELENGTH, cf) != NULL)
  1956.       configline(inputline);
  1957.     return(0);
  1958.   }
  1959. }
  1960.  
  1961. /*** Now the functions to parse the commandline arguments ***/
  1962.  
  1963. /* As in the config commands, first some subfunctions */
  1964.  
  1965. void clflag(flag *f, char *arg)   /* simple on/off switches */
  1966. {
  1967.   if (arg[0] == '-')
  1968.     *f = OFF;
  1969.   else
  1970.     *f = ON;
  1971.   if (arg[2] != '\0' && warnq)
  1972.     fprintf(stderr, "%s: Warning: ignoring extra text after %c%c option\n",
  1973.         commandname, arg[0], arg[1]);
  1974. }
  1975.  
  1976. void cldaterep(flag *f, char *graph, char *arg)
  1977. {
  1978.   if (arg[0] == '-') {
  1979.     *f = OFF;
  1980.     if (arg[2] != '\0' && warnq)
  1981.       fprintf(stderr, "%s: Warning: ignoring extra text after -%c option\n",
  1982.           commandname, arg[1]);
  1983.   }
  1984.   else {
  1985.     *f = ON;
  1986.     if (arg[2] != '\0') {
  1987.       if (arg[2] != 'b' && arg[2] != 'r' && arg[2] != 'B' && arg[2] != 'R') {
  1988.     fprintf(stderr, "%s: Warning: unknown graph method %c at %s\n",
  1989.         commandname, arg[2], arg);
  1990.       }
  1991.       else {
  1992.     *graph = arg[2];
  1993.     if (arg[3] != '\0')
  1994.       fprintf(stderr,
  1995.           "%s: Warning: ignoring extra text after +%c%c option\n",
  1996.           commandname, arg[1], arg[2]);
  1997.       }
  1998.     }
  1999.   }
  2000. }
  2001.  
  2002. void clgenrep(flag *f, int *sortby, char *minreqstr, char *minbytestr,
  2003.           char *arg)    /* generic reports */
  2004. {
  2005.   if (arg[0] == '-') {
  2006.     *f = OFF;
  2007.     if (arg[2] != '\0' && warnq)
  2008.       fprintf(stderr, "%s: Warning: ignoring extra text after -%c option\n",
  2009.           commandname, arg[1]);
  2010.   }
  2011.   else {
  2012.     *f = ON;
  2013.     switch (arg[2]) {
  2014.     case '\0':
  2015.       break;
  2016.     case 'a':
  2017.     case 'A':
  2018.       *sortby = ALPHABETICAL;
  2019.       if (arg[3] != '\0')
  2020.     strcpy(minreqstr, arg + 3);
  2021.       break;
  2022.     case 'b':
  2023.     case 'B':
  2024.       *sortby = BYBYTES;
  2025.       if (arg[3] != '\0')
  2026.     strcpy(minbytestr, arg + 3);
  2027.       break;
  2028.     case 'r':
  2029.     case 'R':
  2030.       *sortby = BYREQUESTS;
  2031.       if (arg[3] != '\0')
  2032.     strcpy(minreqstr, arg + 3);
  2033.       break;
  2034.     case 'x':
  2035.     case 'X':
  2036.       *sortby = RANDOMLY;
  2037.       if (arg[3] != '\0')
  2038.     strcpy(minreqstr, arg + 3);
  2039.       break;
  2040.     default:
  2041.       if (warnq)
  2042.     fprintf(stderr, "%s: Warning: unknown sort method %c at %s\n",
  2043.         commandname, arg[2], arg);
  2044.     }
  2045.   }
  2046. }
  2047.  
  2048. flag clfile(char *filename, char *arg)   /* read in a filename */
  2049. {
  2050.   if (arg[0] == '-') {
  2051.     strcpy(filename, "none");
  2052.     if (arg[2] != '\0' && warnq)
  2053.       fprintf(stderr, "%s: Warning: ignoring extra text after -%c option\n",
  2054.           commandname, arg[1]);
  2055.   }
  2056.   else if (arg[2] == '\0') {
  2057.     if (warnq) {
  2058.       fprintf(stderr, "%s: Warning: no filename supplied after +%c option\n",
  2059.           commandname, arg[1]);
  2060.       fprintf(stderr, "  (or space left before filename)\n");
  2061.     }
  2062.     return(ERR);
  2063.   }
  2064.   else
  2065.     strncpy(filename, arg + 2, MAXSTRINGLENGTH - 1);
  2066.   return(OK);
  2067. }
  2068.  
  2069. /* Now the main commandline command */
  2070.  
  2071. void commandline(int argc, char **argv)
  2072. {
  2073.   int i;
  2074.  
  2075.   flag Gfound = FALSE;
  2076.   char tempstr1[MAXSTRINGLENGTH], tempstr2[MAXSTRINGLENGTH];
  2077.  
  2078.   /* First see whether to include the default config. file, by scanning
  2079.      backwards through the arguments looking for the (last) occurrence of
  2080.      +G or -G. We then run the config. file, then look at the other args. */
  2081.  
  2082.   for (i = argc - 1; i >= 1 && !Gfound; i--) {
  2083.     if (argv[i][1] == 'G') {
  2084.       if (argv[i][2] != '\0' && (argv[i][0] == '+' || argv[i][0] == '-')) {
  2085.     if (warnq) {
  2086.       fprintf(stderr,
  2087.           "%s: Warning: ignoring extra text after %cG option\n",
  2088.           commandname, argv[i][0]);
  2089.     }
  2090.       }
  2091.       if (argv[i][0] == '+') {
  2092.     Gfound = TRUE;
  2093.     config(DEFAULTCONFIGFILE);
  2094.       }
  2095.       else if (argv[i][0] == '-') {
  2096.     Gfound = TRUE;
  2097.       }
  2098.     }
  2099.   }
  2100.   if (!Gfound) {
  2101.     logfilep = logfilehead;
  2102.     cachefilep = cachefilehead;
  2103.     reflogp = refloghead;
  2104.     browlogp = browloghead;
  2105.     errlogp = errloghead;
  2106.     config(DEFAULTCONFIGFILE);
  2107.   }
  2108.  
  2109.   logfilep = logfilehead;  /* reset logfile pointers for over-write */
  2110.   cachefilep = cachefilehead;
  2111.   reflogp = refloghead;
  2112.   browlogp = browloghead;
  2113.   errlogp = errloghead;
  2114.  
  2115.   /* Now read the other arguments */
  2116.  
  2117.   for (i = 1; i < argc; i++) {
  2118.  
  2119.     if (argv[i][0] != '+' && argv[i][0] != '-') {
  2120.       if (STREQ(argv[i], "none")) {
  2121.     logfilep = logfilehead;
  2122.     logfilehead -> name[0] = '\0';
  2123.       }
  2124.       else
  2125.     addlogfile(&logfilep, argv[i], "");
  2126.     }
  2127.     else switch (argv[i][1]) {
  2128.     case '\0':    /* read stdin */
  2129.       addlogfile(&logfilep, "stdin", "");
  2130.       break;
  2131.     case '7':     /* stats for last 7 days */
  2132.       clflag(&q7, argv[i]);
  2133.       break;
  2134.     case 'a':     /* ASCII output */
  2135.       clflag(&aq, argv[i]);  /* This works because ON = ASCII, OFF = HTML */
  2136.       break;      
  2137.     case 'A':     /* all reports */
  2138.       if (argv[i][0] == '-')
  2139.     configline("ALL OFF");
  2140.       else
  2141.     configline("ALL ON");
  2142.       if (argv[i][2] != '\0' && warnq)
  2143.     fprintf(stderr, "%s: Warning: ignoring extra text after %cA option\n",
  2144.         commandname, argv[i][0]);
  2145.       break;
  2146.     case 'b':     /* browser summary */
  2147.       clgenrep(&bq, &browsortby, browminreqstr, browminbytestr, argv[i]);
  2148.       break;
  2149.     case 'B':     /* browser report */
  2150.       clgenrep(&Bq, &fullbrowsortby, fullbrowminreqstr, fullbrowminbytestr,
  2151.            argv[i]);
  2152.       break;
  2153.     case 'c':     /* status code report */
  2154.       clflag(&cq, argv[i]);
  2155.       break;
  2156.     case 'C':     /* configuration command */
  2157.       if (argv[i][2] == '\0') {
  2158.     if (warnq) {
  2159.       fprintf(stderr, "%s: Warning: no command supplied after +C option\n",
  2160.           commandname);
  2161.       fprintf(stderr, "  (or space left before command)\n");
  2162.     }
  2163.       }
  2164.       else
  2165.     configline(argv[i] + 2);
  2166.       break;
  2167.     case 'd':     /* daily summary */
  2168.       cldaterep(&dq, &daygraph, argv[i]);
  2169.       break;
  2170.     case 'D':     /* full daily report */
  2171.       cldaterep(&Dq, &fulldaygraph, argv[i]);
  2172.       break;
  2173.     case 'e':     /* error report */
  2174.       clflag(&eq, argv[i]);
  2175.       break;
  2176.     case 'f':     /* form */
  2177.       if (STREQ(argv[i] + 2, "orm"))
  2178.     formq = ON;
  2179.       else        /* referer report */
  2180.     clgenrep(&fq, &refsortby, refminreqstr, refminbytestr, argv[i]);
  2181.       break;
  2182.     case 'g':     /* configuration file */
  2183.       if (argv[i][0] == '+') {
  2184.     if (argv[i][2] == '\0') {
  2185.       if (warnq) {
  2186.         fprintf(stderr,
  2187.             "%s: Warning: no filename supplied after +g option\n",
  2188.             commandname);
  2189.         fprintf(stderr, "  (or space left before filename)\n");
  2190.       }
  2191.     }
  2192.     else
  2193.       config(argv[i] + 2);
  2194.       }
  2195.       break;
  2196.     case 'F':     /* FROM */
  2197.       if (argv[i][0] == '-') {
  2198.     configline("FROM OFF");
  2199.     if (argv[i][2] != '\0' && warnq)
  2200.       fprintf(stderr, "%s: Warning: ignoring extra text after -F option\n",
  2201.           commandname);
  2202.       }
  2203.       else if (argv[i][2] == '\0' && warnq) {
  2204.     fprintf(stderr, "%s: Warning: no date supplied after +F option\n",
  2205.         commandname);
  2206.     fprintf(stderr, "  (or space left before date)\n");
  2207.       }
  2208.       else {
  2209.     strcpy(tempstr2, "FROM ");
  2210.     strcat(tempstr2, argv[i] + 2);
  2211.     configline(tempstr2);
  2212.       }
  2213.       break;
  2214.     case 'G':     /* default configuration file: done already */
  2215.       break;
  2216.     case 'h':     /* help */
  2217.       if (STREQ(argv[i] + 2, "elp")) {
  2218.     fprintf(stderr, "For help see Readme.html, or\n");
  2219.     fprintf(stderr, "  http://www.statslab.cam.ac.uk/~sret1/analog/analog/Readme.html\n");
  2220.     exit(OK);
  2221.       }
  2222.       else        /* hourly summary */
  2223.     cldaterep(&hq, &hourgraph, argv[i]);
  2224.       break;
  2225.     case 'H':     /* hourly report */
  2226.       cldaterep(&Hq, &fullhourgraph, argv[i]);
  2227.       break;
  2228.     case 'i':     /* directory report */
  2229.       clgenrep(&iq, &dirsortby, dirminreqstr, dirminbytestr, argv[i]);
  2230.       break;
  2231.     case 'k':     /* link to pages in req. report? */
  2232.       if (argv[i][0] == '-') {
  2233.     kq = OFF;
  2234.     if (argv[i][2] != '\0' && warnq)
  2235.       fprintf(stderr, "%s: Warning: ignoring extra text after -k option\n",
  2236.           commandname);
  2237.       }
  2238.       else {
  2239.     kq = ON;
  2240.     if (argv[i][2] == 'k')
  2241.       kq = ALL;
  2242.       }
  2243.       break;
  2244.     case 'l':     /* 'level' of dir report */
  2245.       dirlevel = atoi(argv[i] + 2);
  2246.       break;
  2247.     case 'm':     /* monthly report */
  2248.       cldaterep(&mq, &monthgraph, argv[i]);
  2249.       break;
  2250.     case 'n':     /* our host or organisation name */
  2251.       if (argv[i][2] == '\0') {
  2252.     if (warnq) {
  2253.       fprintf(stderr, "%s: Warning: no text supplied after %cn option\n",
  2254.           commandname, argv[i][0]);
  2255.       fprintf(stderr, "  (or space left before text)\n");
  2256.     }
  2257.       }
  2258.       else
  2259.     strncpy(hostname, argv[i] + 2, MAXSTRINGLENGTH - 1);
  2260.       break;
  2261.     case 'o':                 /* domain report */
  2262.       clgenrep(&oq, &domsortby, domminreqstr, domminbytestr, argv[i]);      
  2263.       break;
  2264.     case 'O':     /* outfile */
  2265.       clfile(outfile, argv[i]);
  2266.       break;
  2267.     case 'p':    /* logo? */
  2268.       clfile(logourl, argv[i]);
  2269.       break;
  2270.     case 'q':    /* warnings? */
  2271.       clflag(&warnq, argv[i]);
  2272.       break;
  2273.     case 'r':    /* request report */
  2274.     case 'R':
  2275.       if (argv[i][0] == '+') {
  2276.     if (argv[i][1] == 'r')
  2277.       reqtype = PAGES;
  2278.     else
  2279.       reqtype = ALL;
  2280.       }
  2281.       clgenrep(&rq, &reqsortby, urlminreqstr, urlminbytestr, argv[i]);
  2282.       break;
  2283.     case 's':      /* count hosts? */
  2284.       if (argv[i][0] == '-')
  2285.     sq = OFF;
  2286.       else if (argv[i][2] == 's')
  2287.     sq = APPROX;
  2288.       else
  2289.     sq = ON;
  2290.       if (argv[i][2] == 's') {
  2291.     if (argv[i][3] != '\0' && warnq)
  2292.       fprintf(stderr,
  2293.           "%s: Warning: ignoring extra text after %css option\n",
  2294.           commandname, argv[i][0]);
  2295.       }
  2296.       else {  /* argv[i][2] != 's' */
  2297.     if (argv[i][2] != '\0' && warnq)
  2298.       fprintf(stderr,
  2299.           "%s: Warning: ignoring extra text after %cs option\n",
  2300.           commandname, argv[i][0]);
  2301.       }
  2302.       break;
  2303.     case 'S':      /* full hostname report */
  2304.       clgenrep(&Sq, &hostsortby, hostminreqstr, hostminbytestr, argv[i]);
  2305.       break;
  2306.     case 'T':     /* TO */
  2307.       if (argv[i][0] == '-') {
  2308.     configline("TO OFF");
  2309.     if (argv[i][2] != '\0' && warnq)
  2310.       fprintf(stderr, "%s: Warning: ignoring extra text after -T option\n",
  2311.           commandname);
  2312.       }
  2313.       else if (argv[i][2] == '\0' && warnq) {
  2314.     fprintf(stderr, "%s: Warning: no date supplied after +T option\n",
  2315.         commandname);
  2316.     fprintf(stderr, "  (or space left before date)\n");
  2317.       }
  2318.       else {
  2319.     strcpy(tempstr2, "TO ");
  2320.     strcat(tempstr2, argv[i] + 2);
  2321.     configline(tempstr2);
  2322.       }
  2323.       break;
  2324.     case 'u':     /* host URL */
  2325.       if (argv[i][2] == '\0') {
  2326.     if (warnq) {
  2327.       fprintf(stderr, "%s: Warning: no URL supplied after %cu option\n",
  2328.           commandname, argv[i][0]);
  2329.       fprintf(stderr, "  (or space left before URL)\n");
  2330.     }
  2331.       }
  2332.       else
  2333.     strncpy(hosturl, argv[i] + 2, MAXSTRINGLENGTH - 1);
  2334.       break;
  2335.     case 'U':      /* cache file */
  2336.       if(clfile(tempstr1, argv[i]) == OK) {
  2337.     strcpy(tempstr2, "CACHEFILE ");
  2338.     strncat(tempstr2, tempstr1, MAXSTRINGLENGTH - 11);
  2339.     configline(tempstr2);
  2340.       }
  2341.       break;
  2342.     case 'v':          /* print variables and exit */
  2343.       if (argv[i][2] != '\0' && warnq)
  2344.     fprintf(stderr, "%s: Warning: ignoring extra text after %cv option\n",
  2345.         commandname, argv[i][0]);
  2346.       vblesonly = ON;
  2347.       break;
  2348.     case 'V':          /* debugging info */
  2349.       if (argv[i][0] == '-') {
  2350.     debug = OFF;
  2351.     if (argv[i][2] != '\0' && warnq)
  2352.       fprintf(stderr, "%s: Warning: ignoring extra text after -V option\n",
  2353.           commandname);
  2354.       }
  2355.       else {
  2356.     if (argv[i][2] == '\0')
  2357.       debug = 1;
  2358.     else
  2359.       debug = atoi(argv[i] + 2);
  2360.       }
  2361.       break;
  2362.     case 'w':          /* pagewidth */
  2363.       pagewidth = atoi(argv[i] + 2);
  2364.       if (pagewidth < MINPAGEWIDTH || pagewidth > MAXPAGEWIDTH) {
  2365.     if (warnq) {
  2366.       fprintf(stderr,"%s: Warning: at option %s, page width should be between %d and %d\n", commandname, argv[i], MINPAGEWIDTH, MAXPAGEWIDTH);
  2367.       fprintf(stderr, "  Resetting to default value of %d\n", PAGEWIDTH);
  2368.     }
  2369.     pagewidth = PAGEWIDTH;
  2370.       }
  2371.       break;
  2372.     case 'W':           /* weekly report */
  2373.       cldaterep(&Wq, &weekgraph, argv[i]);
  2374.       break;
  2375.     case 'x':           /* general summary and gotos */
  2376.       clflag(&xq, argv[i]);
  2377.       break;
  2378.     default:
  2379.       fprintf(stderr,
  2380.       "%s: Error: Unknown option %s: see README.html for correct usage\n",
  2381.           commandname, argv[i]);
  2382.       fprintf(stderr,
  2383.       "  or go to http://www.statslab.cam.ac.uk/~sret1/analog/\n");
  2384.       exit(ERR);
  2385.     }
  2386.   }
  2387.  
  2388.   /* Finally, the mandatory config file */
  2389.   logfilep = logfilehead;  /* reset logfile pointers for over-write */
  2390.   cachefilep = cachefilehead;
  2391.   reflogp = refloghead;
  2392.   browlogp = browloghead;
  2393.   errlogp = errloghead;
  2394.  
  2395.   if (config(MANDATORYCONFIGFILE)) {
  2396.     fprintf(stderr,
  2397.     "%s: Error: Cannot ignore mandatory configuration file: exiting\n",
  2398.         commandname);
  2399.     exit(ERR);
  2400.   }
  2401.  
  2402. }
  2403.  
  2404. /*** The actual initialise() function ***/
  2405.  
  2406. void initialise(int argc, char **argv)
  2407. {
  2408.   extern void formgen();      /* in formgen.c */
  2409.   extern int strtomonth();    /* in utils.c */
  2410.   extern long timecode();     /* in utils.c */
  2411.  
  2412.   char startmonth[4];
  2413.   FILE *outf;
  2414.  
  2415.   time(&starttime);
  2416.   strcpy(starttimestr, ctime(&starttime));
  2417.   starttimec.year = (starttimestr[23] - '0') + (starttimestr[22] - '0') * 10
  2418.     + (starttimestr[21] - '0') * 100 + (starttimestr[20] - '0') * 1000;
  2419.   starttimec.date = (starttimestr[9] - '0');
  2420.   if (starttimestr[8] != ' ')
  2421.     starttimec.date += (starttimestr[8] - '0') * 10;
  2422.   strncpy(startmonth, starttimestr + 4, 3);
  2423.   starttimec.monthno = strtomonth(startmonth);
  2424.   starttimec.code = timecode(starttimec.date, starttimec.monthno,
  2425.                  starttimec.year, 23, 59);
  2426.   /* end of today will be good enough for our purposes */
  2427.  
  2428.   defaults();   /* enter the defaults for all the variables
  2429.            (before possibly changing them). */
  2430.  
  2431.   init_structs();   /* initialise all the structures (and pointers to them) */
  2432.  
  2433.   strncpy(commandname, argv[0], MAXSTRINGLENGTH - 1);
  2434.  
  2435.   commandline(argc, argv);  /* parse commandline. This also parses all the
  2436.                    configuration files. */
  2437.  
  2438.   /* correct any variables for which wrong value given */
  2439.  
  2440.   if (fromtime.code > totime.code) {
  2441.     fprintf(stderr, "%s: Error: FROM and TO exclude all dates.\n",
  2442.         commandname);
  2443.     exit(ERR);
  2444.   }
  2445.  
  2446.   if (dirlevel == 0)
  2447.     dirlevel = 1;
  2448.  
  2449.   if (Sq)
  2450.     sq = ON;      /* +S implies +s */
  2451.  
  2452.   if (STREQ(baseurl, "none"))
  2453.     baseurl[0] = '\0';
  2454.  
  2455.   if (!STREQ(outfile, "stdout")) {
  2456.     if ((outf = fopen(outfile, "w")) == NULL) {
  2457.       fprintf(stderr,
  2458.           "%s: Error: failed to open output file %s for writing.\n",
  2459.           commandname, outfile);
  2460.       exit(ERR);   /* test now so we don't do the processing THEN find out */
  2461.     }
  2462.     else
  2463.       fclose(outf);  /* no need to hold it open */
  2464.   }
  2465.  
  2466.   if (aq == CACHE) {
  2467.     configline("ALL OFF");
  2468.     xq = OFF;
  2469.     Hq = ON;
  2470.     Hback = OFF;
  2471.   }
  2472.  
  2473.   /* if we just want a form, generate that and exit */
  2474.  
  2475.   if (formq) {
  2476.     formgen();
  2477.     exit(OK);
  2478.   }
  2479.  
  2480.   if (!vblesonly)
  2481.     othervars();
  2482.  
  2483. }   /* end initialise() */
  2484.  
  2485.  
  2486. /*** Finally, boring functions just to print variables and exit ***/
  2487.  
  2488. void pvfilelist(struct stringlist *head, char filetype[MAXSTRINGLENGTH])
  2489. {
  2490.   FILE *filep;
  2491.   struct stringlist *p;
  2492.  
  2493.   printf("%s to analyse:\n", filetype);
  2494.   if (head -> name[0] == '\0')
  2495.     printf("  none\n");
  2496.   for (p = head; p -> name[0] != '\0'; p = p -> next) {  /* for each file */
  2497.     printf("  %s", p -> name);
  2498.     if ((filep = fopen(p -> name, "r")) == NULL && !STREQ(p -> name, "stdin"))
  2499.       printf(":   Warning: cannot open that file");
  2500.     else
  2501.       fclose(filep);  /* NB So condl 3 lines back must be in that order */
  2502.       printf("\n");
  2503.   }
  2504. }
  2505.  
  2506. void pvcols(char *cols)
  2507. {
  2508.   char *c;
  2509.  
  2510.   printf("  Columns:");
  2511.   if (*cols == '\0')
  2512.     printf("  none");
  2513.   else for (c = dircols; *c != '\0'; c++) {
  2514.     switch(*c) {
  2515.     case 'b':
  2516.       printf("  %%bytes");
  2517.       break;
  2518.     case 'B':
  2519.       printf("  #bytes");
  2520.       break;
  2521.     case 'r':
  2522.       printf("  %%requests");
  2523.       break;
  2524.     case 'R':
  2525.       printf("  #requests");
  2526.       break;
  2527.     }
  2528.   }
  2529.   printf("\n");
  2530. }
  2531.  
  2532. void pvtime(char name[15], flag q, char graph, int unit, char cols[])
  2533. {
  2534.   extern void int3printf();     /* in utils.c */
  2535.  
  2536.   int i;
  2537.  
  2538.   printf("%s", name);
  2539.   for (i = 19 - (int)strlen(name); i--; i > 0)
  2540.     printf(" ");
  2541.   printf("%s\n", q?"ON":"OFF");
  2542.   if (q) {
  2543.     printf("  Drawing bar chart by %s\n",
  2544.        (graph == 'b' || graph == 'B')?"bytes":"requests");
  2545.     if (unit != 0) {
  2546.       printf("  Each character in the graph will represent");
  2547.       int3printf(stdout, unit);
  2548.       printf("%s\n", (graph == 'b' || graph == 'B')?"bytes":"requests");
  2549.     }
  2550.     pvcols(cols);
  2551.   }
  2552. }
  2553.  
  2554. void pvgen(char name[17], flag q, int sortby, char *minreqstr,
  2555.        char *minbytestr, char cols[], char singular[20], char plural[21])
  2556. {
  2557.   extern int whatincluded();        /* in output.c */
  2558.  
  2559.   int i;
  2560.  
  2561.   printf("%s", name);
  2562.   for (i = 19 - (int)strlen(name); i--; i > 0)
  2563.     printf(" ");
  2564.   printf("%s\n", q?"ON":"OFF");
  2565.   if (q) {
  2566.     printf("  ");
  2567.     whatincluded(stdout, sortby, minreqstr, minbytestr, singular, plural, OFF);
  2568.     pvcols(cols);
  2569.   }
  2570. }
  2571.  
  2572. void pvinout(char name[9], struct include *head)
  2573. {
  2574.   struct include *p;
  2575.  
  2576.   printf("\nIncluding (+) and excluding (-) the following %s:\n", name);
  2577.   printf("  All %s, then\n", (head -> in == TRUE)?"excluded":"included");
  2578.   for (p = head; p -> in != UNSET; p = p -> next)
  2579.     printf("  %c %s\n", (p -> in)?'+':'-', p -> name);
  2580. }
  2581.  
  2582. void pvalias(char name[8], struct alias *head)
  2583. {
  2584.   struct alias *p;
  2585.  
  2586.   if (head -> from[0] != '\0') {
  2587.     printf("%s aliases:\n", name);
  2588.     for (p = head; p -> from[0] != '\0'; p = p -> next)
  2589.       printf("  %s -> %s", p -> from, p -> to);
  2590.     printf("\n");
  2591.   }
  2592. }
  2593.  
  2594. void printvbles(void)
  2595. {
  2596.   extern void int3printf();     /* in utils.c */
  2597.   extern int whatincluded();    /* in output.c */
  2598.  
  2599.   FILE *filep;
  2600.   char *c;
  2601.  
  2602.   printf("This is analog version %s\n", VERSION);
  2603.   printf("For more information on analog see Readme.html or\n");
  2604.   printf("http://www.statslab.cam.ac.uk/~sret1/analog/\n\n");
  2605.  
  2606.   printf("Logfiles to analyse:\n");  /* as printfilelist(), but for logfiles */
  2607.   if (logfilehead -> name[0] == '\0')
  2608.     printf("  none\n");
  2609.   for (logfilep = logfilehead; logfilep -> name[0] != '\0';
  2610.        logfilep = logfilep -> next) {
  2611.     printf("  %s", logfilep -> name);
  2612.     if ((filep = fopen(logfilep -> name, "r")) == NULL &&
  2613.     !STREQ(logfilep -> name, "stdin"))
  2614.       printf(":   Warning: cannot open that file");
  2615.     else
  2616.       fclose(filep);  /* NB So condl 3 lines back must be in that order */
  2617.     printf("\n");
  2618.   }
  2619.  
  2620.   pvfilelist(cachefilehead, "Cache files");
  2621.  
  2622.   if (aq != CACHE) {
  2623.     pvfilelist(refloghead, "Referer logs");
  2624.     pvfilelist(browloghead, "Browser logs");
  2625.     pvfilelist(errloghead, "Error logs");
  2626.   }
  2627.  
  2628.   if (uncompresshead -> name[0] != '\0') {
  2629.     printf("Files uncompressed by the following methods:\n");
  2630.     for (uncompressp = uncompresshead; uncompressp -> name[0] != '\0';
  2631.      uncompressp = uncompressp -> next)
  2632.       printf("  %s by %s\n", uncompressp -> name, uncompressp -> prefix);
  2633.   }
  2634.  
  2635.   if (aq == CACHE)
  2636.     printf("\nOutputting cache file only.\n");
  2637.   else {
  2638.     printf("The domains file is %s\n", domainsfile);
  2639.     if ((filep = fopen(domainsfile, "r")) == NULL)
  2640.       printf("  Warning: cannot open that file: cannot construct domain report\n");
  2641.     else
  2642.       fclose(filep);
  2643.  
  2644.     printf("The output file is %s\n", outfile);
  2645.     /* Don't check for being able to write as it will destroy the file */
  2646.  
  2647.     printf("\nReport order:\n");
  2648.     printf("General summary    %s\n", xq?"ON":"OFF");
  2649.     for (c = reportorder; *c != '\0'; c++) {
  2650.       switch(*c) {
  2651.       case 'b':
  2652.     pvgen("Browser summary", bq, browsortby, browminreqstr, browminbytestr,
  2653.           browcols, "browser", "browsers");
  2654.     break;
  2655.       case 'B':
  2656.     pvgen("Browser report", Bq, fullbrowsortby, fullbrowminreqstr,
  2657.           fullbrowminbytestr, fullbrowcols, "browser", "browsers");
  2658.     break;
  2659.       case 'c':
  2660.     printf("Status code report %s\n", cq?"ON":"OFF");
  2661.     break;
  2662.       case 'd':
  2663.     pvtime("Daily summary", dq, daygraph, dailyunit, daycols);
  2664.     break;
  2665.       case 'D':
  2666.     pvtime("Daily report", Dq, fulldaygraph, fulldailyunit, fulldaycols);
  2667.     break;
  2668.       case 'e':
  2669.     printf("Error report       %s\n", eq?"ON":"OFF");
  2670.     if (errminreqs == 0)
  2671.       printf("  Printing all possible errors, ");
  2672.     else
  2673.       printf("  Printing all errors with at least %d occurence%s,\n",
  2674.          errminreqs, (errminreqs == 1)?"":"s");
  2675.     printf("  sorted by number of occurrences.");
  2676.     break;
  2677.       case 'f':
  2678.     pvgen("Referer report", fq, refsortby, refminreqstr, refminbytestr,
  2679.           refcols, "referer", "referers");
  2680.     break;
  2681.       case 'h':
  2682.     pvtime("Hourly summary", hq, hourgraph, hourlyunit, hourcols);
  2683.     break;
  2684.       case 'H':
  2685.     pvtime("Hourly report", Hq, fullhourgraph, fullhourlyunit,
  2686.            fullhourcols);
  2687.     break;
  2688.       case 'i':
  2689.     pvgen("Directory report", iq, dirsortby, dirminreqstr, dirminbytestr,
  2690.           dircols, "directory", "directories");
  2691.     printf("  Printing directories to depth %d.\n", dirlevel);
  2692.     break;
  2693.       case 'm':
  2694.     pvtime("Monthly report", mq, monthgraph, monthlyunit, monthcols);
  2695.     break;
  2696.       case 'o':
  2697.     pvgen("Domain report", oq, domsortby, domminreqstr, domminbytestr,
  2698.           domcols, "domain", "domains");
  2699.     printf("  ");
  2700.     whatincluded(stdout, domsortby, domminreqstr, domminbytestr,
  2701.              "requested subdomain", "requested subdomains", ON);
  2702.     break;
  2703.       case 'r':
  2704.     pvgen("Request report", rq, reqsortby, urlminreqstr, urlminbytestr,
  2705.           reqcols, (reqtype == PAGES)?"page":"file",
  2706.           (reqtype == PAGES)?"pages":"files");
  2707.     if (kq == OFF)
  2708.       printf("  Linking disabled.\n");
  2709.     else {
  2710.       printf("  Linking to %s enabled", (kq==ALL)?"all files":"pages");
  2711.       if (baseurl[0] != '\0')
  2712.         printf(" (prepended by %s)", baseurl);
  2713.       printf(".\n");
  2714.     }
  2715.     break;
  2716.       case 'S':
  2717.     pvgen("Host report", Sq, hostsortby, hostminreqstr, hostminbytestr,
  2718.           hostcols, "host", "hosts");
  2719.     break;
  2720.       case 'W':
  2721.     pvtime("Weekly report", Wq, weekgraph, weeklyunit, weekcols);
  2722.     break;
  2723.       }  /* end switch c */
  2724.     }    /* end for c */
  2725.     
  2726.  
  2727.     if (sq == APPROX) {
  2728.       printf("\nApproximate hostname count ON\n");
  2729.       printf("  Space used for hostname count: ");
  2730.       int3printf(stdout, approxhostsize);
  2731.       printf(" bytes\n");
  2732.     }
  2733.     else
  2734.       printf("\nHostname count     %s\n", (sq == ON)?"ON":"OFF");
  2735.  
  2736.     printf("Statistics for last 7 days %s\n", q7?"ON":"OFF");
  2737.  
  2738.     if (oq) {
  2739.       printf("\nRequested subdomains:\n");
  2740.       if (subdomshead -> from[0] == '\0')
  2741.     printf("  None\n");
  2742.       else for (subdomp = subdomshead; subdomp -> from[0] != '\0';
  2743.         subdomp = subdomp -> next) {
  2744.     if (subdomp -> from[0] == '?')  /* don't want it */
  2745.       ;
  2746.     else if (subdomp -> from[0] == '%')
  2747.       printf("  Numerical subdomains\n");
  2748.     else {
  2749.       printf("  %s", subdomp -> from);
  2750.       if (subdomp -> to[0] != '?')
  2751.         printf(" (%s)", subdomp -> to);
  2752.       printf("\n");
  2753.     }
  2754.       }
  2755.     }
  2756.     
  2757.     if (mq || dq || hq || Hq || Dq || Wq) {
  2758.       printf("\nThe character used in the graphs will be '%c'\n", markchar);
  2759.       printf("The page width is %d\n", pagewidth);
  2760.     }
  2761.  
  2762.     if (sepchar != '\0')
  2763.       printf("The character used as a separator in big numbers will be '%c'\n",
  2764.          sepchar);
  2765.  
  2766.     if (Wq || Dq || dq) {
  2767.       printf("Weeks are taken to begin on ");
  2768.       switch(weekbeginson) {
  2769.       case (SUNDAY):
  2770.     printf("Sunday.\n");
  2771.     break;
  2772.       case (MONDAY):
  2773.     printf("Monday.\n");
  2774.     break;
  2775.       case (TUESDAY):
  2776.     printf("Tuesday.\n");
  2777.     break;
  2778.       case (WEDNESDAY):
  2779.     printf("Wednesday.\n");
  2780.     break;
  2781.       case (THURSDAY):
  2782.       printf("Thursday.\n");
  2783.     break;
  2784.       case (FRIDAY):
  2785.     printf("Friday.\n");
  2786.     break;
  2787.       case (SATURDAY):
  2788.     printf("Saturday.\n");
  2789.       break;
  2790.       }
  2791.     }
  2792.  
  2793.     printf("\nThe output will be in %s.\n",aq?"plain text":"HTML");
  2794.     printf("The following will be included in the output:\n");
  2795.  
  2796.     if (!aq)
  2797.       printf("Logo               %s\n", STREQ(logourl, "none")?logourl:"OFF");
  2798.     printf("Header file        %s\n",
  2799.        STREQ(headerfile, "none")?"OFF":headerfile);
  2800.     if (!STREQ(headerfile, "none")) {
  2801.       if ((filep = fopen(headerfile, "r")) == NULL)
  2802.     printf("  Warning: cannot open that file: will ignore it\n");
  2803.       else
  2804.     fclose(filep);
  2805.     }
  2806.     printf("Footer file        %s\n",
  2807.        STREQ(footerfile, "none")?"OFF":footerfile);
  2808.     if (!STREQ(footerfile, "none")) {
  2809.       if ((filep = fopen(footerfile, "r")) == NULL)
  2810.     printf("  Warning: cannot open that file: will ignore it\n");
  2811.       else
  2812.     fclose(filep);
  2813.     }
  2814.     printf("Organisation name  \"%s\"\n", hostname);
  2815.     if (!aq)
  2816.       printf("Name linked to URL %s\n\n", (hosturl[0]=='-')?"OFF":hosturl);
  2817.  
  2818.   pvinout("as pages", ispagehead);
  2819.   pvalias("File", filealiashead);
  2820.   pvalias("Host", hostaliashead);
  2821.   pvalias("Referer", refaliashead);
  2822.  
  2823.   }   /* end if aq != CACHE */
  2824.  
  2825.   if (filemaskq)
  2826.     pvinout("files", wantfilehead);
  2827.   if (hostmaskq)
  2828.     pvinout("hosts", wanthosthead);
  2829.   if (refmaskq && aq != CACHE)
  2830.     pvinout("referers", wantrefhead);
  2831.  
  2832.   if (fromtime.code > -INFINITY || totime.code < INFINITY) {
  2833.     printf("\nExamining only times");
  2834.     if (fromtime.code > -INFINITY)
  2835.       printf(" from %02d/%s/%d", fromtime.date,
  2836.          monthname[fromtime.monthno], fromtime.year);
  2837.     if (totime.code < INFINITY)
  2838.       printf(" to %02d/%s/%d", totime.date,
  2839.          monthname[totime.monthno], totime.year);
  2840.     printf("\n");
  2841.   }
  2842.  
  2843.   printf("\nDebug level is %d\n\n", debug);
  2844.  
  2845.   exit(OK);
  2846.  
  2847. }
  2848.